././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1758639645.972687 asgiref-3.9.2/0000755000076500000240000000000015064533036012537 5ustar00carltonstaff././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1650354462.0 asgiref-3.9.2/LICENSE0000644000076500000240000000302014227464436013546 0ustar00carltonstaffCopyright (c) Django Software Foundation and individual contributors. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of Django nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1733559318.0 asgiref-3.9.2/MANIFEST.in0000644000076500000240000000012614725002026014265 0ustar00carltonstaffinclude LICENSE include asgiref/py.typed include tox.ini recursive-include tests *.py ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1758639645.9726183 asgiref-3.9.2/PKG-INFO0000644000076500000240000002210615064533036013635 0ustar00carltonstaffMetadata-Version: 2.4 Name: asgiref Version: 3.9.2 Summary: ASGI specs, helper code, and adapters Home-page: https://github.com/django/asgiref/ Author: Django Software Foundation Author-email: foundation@djangoproject.com License: BSD-3-Clause Project-URL: Documentation, https://asgi.readthedocs.io/ Project-URL: Further Documentation, https://docs.djangoproject.com/en/stable/topics/async/#async-adapter-functions Project-URL: Changelog, https://github.com/django/asgiref/blob/master/CHANGELOG.txt Classifier: Development Status :: 5 - Production/Stable Classifier: Environment :: Web Environment Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: BSD License Classifier: Operating System :: OS Independent Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3 :: Only Classifier: Programming Language :: Python :: 3.9 Classifier: Programming Language :: Python :: 3.10 Classifier: Programming Language :: Python :: 3.11 Classifier: Programming Language :: Python :: 3.12 Classifier: Programming Language :: Python :: 3.13 Classifier: Topic :: Internet :: WWW/HTTP Requires-Python: >=3.9 License-File: LICENSE Requires-Dist: typing_extensions>=4; python_version < "3.11" Provides-Extra: tests Requires-Dist: pytest; extra == "tests" Requires-Dist: pytest-asyncio; extra == "tests" Requires-Dist: mypy>=1.14.0; extra == "tests" Dynamic: license-file asgiref ======= .. image:: https://github.com/django/asgiref/actions/workflows/tests.yml/badge.svg :target: https://github.com/django/asgiref/actions/workflows/tests.yml .. image:: https://img.shields.io/pypi/v/asgiref.svg :target: https://pypi.python.org/pypi/asgiref ASGI is a standard for Python asynchronous web apps and servers to communicate with each other, and positioned as an asynchronous successor to WSGI. You can read more at https://asgi.readthedocs.io/en/latest/ This package includes ASGI base libraries, such as: * Sync-to-async and async-to-sync function wrappers, ``asgiref.sync`` * Server base classes, ``asgiref.server`` * A WSGI-to-ASGI adapter, in ``asgiref.wsgi`` Function wrappers ----------------- These allow you to wrap or decorate async or sync functions to call them from the other style (so you can call async functions from a synchronous thread, or vice-versa). In particular: * AsyncToSync lets a synchronous subthread stop and wait while the async function is called on the main thread's event loop, and then control is returned to the thread when the async function is finished. * SyncToAsync lets async code call a synchronous function, which is run in a threadpool and control returned to the async coroutine when the synchronous function completes. The idea is to make it easier to call synchronous APIs from async code and asynchronous APIs from synchronous code so it's easier to transition code from one style to the other. In the case of Channels, we wrap the (synchronous) Django view system with SyncToAsync to allow it to run inside the (asynchronous) ASGI server. Note that exactly what threads things run in is very specific, and aimed to keep maximum compatibility with old synchronous code. See "Synchronous code & Threads" below for a full explanation. By default, ``sync_to_async`` will run all synchronous code in the program in the same thread for safety reasons; you can disable this for more performance with ``@sync_to_async(thread_sensitive=False)``, but make sure that your code does not rely on anything bound to threads (like database connections) when you do. Threadlocal replacement ----------------------- This is a drop-in replacement for ``threading.local`` that works with both threads and asyncio Tasks. Even better, it will proxy values through from a task-local context to a thread-local context when you use ``sync_to_async`` to run things in a threadpool, and vice-versa for ``async_to_sync``. If you instead want true thread- and task-safety, you can set ``thread_critical`` on the Local object to ensure this instead. Server base classes ------------------- Includes a ``StatelessServer`` class which provides all the hard work of writing a stateless server (as in, does not handle direct incoming sockets but instead consumes external streams or sockets to work out what is happening). An example of such a server would be a chatbot server that connects out to a central chat server and provides a "connection scope" per user chatting to it. There's only one actual connection, but the server has to separate things into several scopes for easier writing of the code. You can see an example of this being used in `frequensgi `_. WSGI-to-ASGI adapter -------------------- Allows you to wrap a WSGI application so it appears as a valid ASGI application. Simply wrap it around your WSGI application like so:: asgi_application = WsgiToAsgi(wsgi_application) The WSGI application will be run in a synchronous threadpool, and the wrapped ASGI application will be one that accepts ``http`` class messages. Please note that not all extended features of WSGI may be supported (such as file handles for incoming POST bodies). Dependencies ------------ ``asgiref`` requires Python 3.9 or higher. Contributing ------------ Please refer to the `main Channels contributing docs `_. Testing ''''''' To run tests, make sure you have installed the ``tests`` extra with the package:: cd asgiref/ pip install -e .[tests] pytest Building the documentation '''''''''''''''''''''''''' The documentation uses `Sphinx `_:: cd asgiref/docs/ pip install sphinx To build the docs, you can use the default tools:: sphinx-build -b html . _build/html # or `make html`, if you've got make set up cd _build/html python -m http.server ...or you can use ``sphinx-autobuild`` to run a server and rebuild/reload your documentation changes automatically:: pip install sphinx-autobuild sphinx-autobuild . _build/html Releasing ''''''''' To release, first add details to CHANGELOG.txt and update the version number in ``asgiref/__init__.py``. Then, build and push the packages:: python -m build twine upload dist/* rm -r asgiref.egg-info dist Implementation Details ---------------------- Synchronous code & threads '''''''''''''''''''''''''' The ``asgiref.sync`` module provides two wrappers that let you go between asynchronous and synchronous code at will, while taking care of the rough edges for you. Unfortunately, the rough edges are numerous, and the code has to work especially hard to keep things in the same thread as much as possible. Notably, the restrictions we are working with are: * All synchronous code called through ``SyncToAsync`` and marked with ``thread_sensitive`` should run in the same thread as each other (and if the outer layer of the program is synchronous, the main thread) * If a thread already has a running async loop, ``AsyncToSync`` can't run things on that loop if it's blocked on synchronous code that is above you in the call stack. The first compromise you get to might be that ``thread_sensitive`` code should just run in the same thread and not spawn in a sub-thread, fulfilling the first restriction, but that immediately runs you into the second restriction. The only real solution is to essentially have a variant of ThreadPoolExecutor that executes any ``thread_sensitive`` code on the outermost synchronous thread - either the main thread, or a single spawned subthread. This means you now have two basic states: * If the outermost layer of your program is synchronous, then all async code run through ``AsyncToSync`` will run in a per-call event loop in arbitrary sub-threads, while all ``thread_sensitive`` code will run in the main thread. * If the outermost layer of your program is asynchronous, then all async code runs on the main thread's event loop, and all ``thread_sensitive`` synchronous code will run in a single shared sub-thread. Crucially, this means that in both cases there is a thread which is a shared resource that all ``thread_sensitive`` code must run on, and there is a chance that this thread is currently blocked on its own ``AsyncToSync`` call. Thus, ``AsyncToSync`` needs to act as an executor for thread code while it's blocking. The ``CurrentThreadExecutor`` class provides this functionality; rather than simply waiting on a Future, you can call its ``run_until_future`` method and it will run submitted code until that Future is done. This means that code inside the call can then run code on your thread. Maintenance and Security ------------------------ To report security issues, please contact security@djangoproject.com. For GPG signatures and more security process information, see https://docs.djangoproject.com/en/dev/internals/security/. To report bugs or request new features, please open a new GitHub issue. This repository is part of the Channels project. For the shepherd and maintenance team, please see the `main Channels readme `_. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1733559318.0 asgiref-3.9.2/README.rst0000644000076500000240000001721114725002026014221 0ustar00carltonstaffasgiref ======= .. image:: https://github.com/django/asgiref/actions/workflows/tests.yml/badge.svg :target: https://github.com/django/asgiref/actions/workflows/tests.yml .. image:: https://img.shields.io/pypi/v/asgiref.svg :target: https://pypi.python.org/pypi/asgiref ASGI is a standard for Python asynchronous web apps and servers to communicate with each other, and positioned as an asynchronous successor to WSGI. You can read more at https://asgi.readthedocs.io/en/latest/ This package includes ASGI base libraries, such as: * Sync-to-async and async-to-sync function wrappers, ``asgiref.sync`` * Server base classes, ``asgiref.server`` * A WSGI-to-ASGI adapter, in ``asgiref.wsgi`` Function wrappers ----------------- These allow you to wrap or decorate async or sync functions to call them from the other style (so you can call async functions from a synchronous thread, or vice-versa). In particular: * AsyncToSync lets a synchronous subthread stop and wait while the async function is called on the main thread's event loop, and then control is returned to the thread when the async function is finished. * SyncToAsync lets async code call a synchronous function, which is run in a threadpool and control returned to the async coroutine when the synchronous function completes. The idea is to make it easier to call synchronous APIs from async code and asynchronous APIs from synchronous code so it's easier to transition code from one style to the other. In the case of Channels, we wrap the (synchronous) Django view system with SyncToAsync to allow it to run inside the (asynchronous) ASGI server. Note that exactly what threads things run in is very specific, and aimed to keep maximum compatibility with old synchronous code. See "Synchronous code & Threads" below for a full explanation. By default, ``sync_to_async`` will run all synchronous code in the program in the same thread for safety reasons; you can disable this for more performance with ``@sync_to_async(thread_sensitive=False)``, but make sure that your code does not rely on anything bound to threads (like database connections) when you do. Threadlocal replacement ----------------------- This is a drop-in replacement for ``threading.local`` that works with both threads and asyncio Tasks. Even better, it will proxy values through from a task-local context to a thread-local context when you use ``sync_to_async`` to run things in a threadpool, and vice-versa for ``async_to_sync``. If you instead want true thread- and task-safety, you can set ``thread_critical`` on the Local object to ensure this instead. Server base classes ------------------- Includes a ``StatelessServer`` class which provides all the hard work of writing a stateless server (as in, does not handle direct incoming sockets but instead consumes external streams or sockets to work out what is happening). An example of such a server would be a chatbot server that connects out to a central chat server and provides a "connection scope" per user chatting to it. There's only one actual connection, but the server has to separate things into several scopes for easier writing of the code. You can see an example of this being used in `frequensgi `_. WSGI-to-ASGI adapter -------------------- Allows you to wrap a WSGI application so it appears as a valid ASGI application. Simply wrap it around your WSGI application like so:: asgi_application = WsgiToAsgi(wsgi_application) The WSGI application will be run in a synchronous threadpool, and the wrapped ASGI application will be one that accepts ``http`` class messages. Please note that not all extended features of WSGI may be supported (such as file handles for incoming POST bodies). Dependencies ------------ ``asgiref`` requires Python 3.9 or higher. Contributing ------------ Please refer to the `main Channels contributing docs `_. Testing ''''''' To run tests, make sure you have installed the ``tests`` extra with the package:: cd asgiref/ pip install -e .[tests] pytest Building the documentation '''''''''''''''''''''''''' The documentation uses `Sphinx `_:: cd asgiref/docs/ pip install sphinx To build the docs, you can use the default tools:: sphinx-build -b html . _build/html # or `make html`, if you've got make set up cd _build/html python -m http.server ...or you can use ``sphinx-autobuild`` to run a server and rebuild/reload your documentation changes automatically:: pip install sphinx-autobuild sphinx-autobuild . _build/html Releasing ''''''''' To release, first add details to CHANGELOG.txt and update the version number in ``asgiref/__init__.py``. Then, build and push the packages:: python -m build twine upload dist/* rm -r asgiref.egg-info dist Implementation Details ---------------------- Synchronous code & threads '''''''''''''''''''''''''' The ``asgiref.sync`` module provides two wrappers that let you go between asynchronous and synchronous code at will, while taking care of the rough edges for you. Unfortunately, the rough edges are numerous, and the code has to work especially hard to keep things in the same thread as much as possible. Notably, the restrictions we are working with are: * All synchronous code called through ``SyncToAsync`` and marked with ``thread_sensitive`` should run in the same thread as each other (and if the outer layer of the program is synchronous, the main thread) * If a thread already has a running async loop, ``AsyncToSync`` can't run things on that loop if it's blocked on synchronous code that is above you in the call stack. The first compromise you get to might be that ``thread_sensitive`` code should just run in the same thread and not spawn in a sub-thread, fulfilling the first restriction, but that immediately runs you into the second restriction. The only real solution is to essentially have a variant of ThreadPoolExecutor that executes any ``thread_sensitive`` code on the outermost synchronous thread - either the main thread, or a single spawned subthread. This means you now have two basic states: * If the outermost layer of your program is synchronous, then all async code run through ``AsyncToSync`` will run in a per-call event loop in arbitrary sub-threads, while all ``thread_sensitive`` code will run in the main thread. * If the outermost layer of your program is asynchronous, then all async code runs on the main thread's event loop, and all ``thread_sensitive`` synchronous code will run in a single shared sub-thread. Crucially, this means that in both cases there is a thread which is a shared resource that all ``thread_sensitive`` code must run on, and there is a chance that this thread is currently blocked on its own ``AsyncToSync`` call. Thus, ``AsyncToSync`` needs to act as an executor for thread code while it's blocking. The ``CurrentThreadExecutor`` class provides this functionality; rather than simply waiting on a Future, you can call its ``run_until_future`` method and it will run submitted code until that Future is done. This means that code inside the call can then run code on your thread. Maintenance and Security ------------------------ To report security issues, please contact security@djangoproject.com. For GPG signatures and more security process information, see https://docs.djangoproject.com/en/dev/internals/security/. To report bugs or request new features, please open a new GitHub issue. This repository is part of the Channels project. For the shepherd and maintenance team, please see the `main Channels readme `_. ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1758639645.9683623 asgiref-3.9.2/asgiref/0000755000076500000240000000000015064533036014157 5ustar00carltonstaff././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1758639532.0 asgiref-3.9.2/asgiref/__init__.py0000644000076500000240000000002615064532654016273 0ustar00carltonstaff__version__ = "3.9.2" ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1671095091.0 asgiref-3.9.2/asgiref/compatibility.py0000644000076500000240000000310614346561463017411 0ustar00carltonstaffimport inspect from .sync import iscoroutinefunction def is_double_callable(application): """ Tests to see if an application is a legacy-style (double-callable) application. """ # Look for a hint on the object first if getattr(application, "_asgi_single_callable", False): return False if getattr(application, "_asgi_double_callable", False): return True # Uninstanted classes are double-callable if inspect.isclass(application): return True # Instanted classes depend on their __call__ if hasattr(application, "__call__"): # We only check to see if its __call__ is a coroutine function - # if it's not, it still might be a coroutine function itself. if iscoroutinefunction(application.__call__): return False # Non-classes we just check directly return not iscoroutinefunction(application) def double_to_single_callable(application): """ Transforms a double-callable ASGI application into a single-callable one. """ async def new_application(scope, receive, send): instance = application(scope) return await instance(receive, send) return new_application def guarantee_single_callable(application): """ Takes either a single- or double-callable application and always returns it in single-callable style. Use this to add backwards compatibility for ASGI 2.0 applications to your server/test harness/etc. """ if is_double_callable(application): application = double_to_single_callable(application) return application ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1751534769.0 asgiref-3.9.2/asgiref/current_thread_executor.py0000644000076500000240000001007515031446261021460 0ustar00carltonstaffimport sys import threading from collections import deque from concurrent.futures import Executor, Future from typing import Any, Callable, TypeVar if sys.version_info >= (3, 10): from typing import ParamSpec else: from typing_extensions import ParamSpec _T = TypeVar("_T") _P = ParamSpec("_P") _R = TypeVar("_R") class _WorkItem: """ Represents an item needing to be run in the executor. Copied from ThreadPoolExecutor (but it's private, so we're not going to rely on importing it) """ def __init__( self, future: "Future[_R]", fn: Callable[_P, _R], *args: _P.args, **kwargs: _P.kwargs, ): self.future = future self.fn = fn self.args = args self.kwargs = kwargs def run(self) -> None: __traceback_hide__ = True # noqa: F841 if not self.future.set_running_or_notify_cancel(): return try: result = self.fn(*self.args, **self.kwargs) except BaseException as exc: self.future.set_exception(exc) # Break a reference cycle with the exception 'exc' self = None # type: ignore[assignment] else: self.future.set_result(result) class CurrentThreadExecutor(Executor): """ An Executor that actually runs code in the thread it is instantiated in. Passed to other threads running async code, so they can run sync code in the thread they came from. """ def __init__(self, old_executor: "CurrentThreadExecutor | None") -> None: self._work_thread = threading.current_thread() self._work_ready = threading.Condition(threading.Lock()) self._work_items = deque[_WorkItem]() # synchronized by _work_ready self._broken = False # synchronized by _work_ready self._old_executor = old_executor def run_until_future(self, future: "Future[Any]") -> None: """ Runs the code in the work queue until a result is available from the future. Should be run from the thread the executor is initialised in. """ # Check we're in the right thread if threading.current_thread() != self._work_thread: raise RuntimeError( "You cannot run CurrentThreadExecutor from a different thread" ) def done(future: "Future[Any]") -> None: with self._work_ready: self._broken = True self._work_ready.notify() future.add_done_callback(done) # Keep getting and running work items until the future we're waiting for # is done and the queue is empty. while True: with self._work_ready: while not self._work_items and not self._broken: self._work_ready.wait() if not self._work_items: break # Get a work item and run it work_item = self._work_items.popleft() work_item.run() del work_item def submit( self, fn: Callable[_P, _R], /, *args: _P.args, **kwargs: _P.kwargs, ) -> "Future[_R]": # Check they're not submitting from the same thread if threading.current_thread() == self._work_thread: raise RuntimeError( "You cannot submit onto CurrentThreadExecutor from its own thread" ) f: "Future[_R]" = Future() work_item = _WorkItem(f, fn, *args, **kwargs) # Walk up the CurrentThreadExecutor stack to find the closest one still # running executor = self while True: with executor._work_ready: if not executor._broken: # Add to work queue executor._work_items.append(work_item) executor._work_ready.notify() break if executor._old_executor is None: raise RuntimeError("CurrentThreadExecutor already quit or is broken") executor = executor._old_executor # Return the future return f ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1751965418.0 asgiref-3.9.2/asgiref/local.py0000644000076500000240000001146015033157352015624 0ustar00carltonstaffimport asyncio import contextlib import contextvars import threading from typing import Any, Dict, Union class _CVar: """Storage utility for Local.""" def __init__(self) -> None: self._data: "contextvars.ContextVar[Dict[str, Any]]" = contextvars.ContextVar( "asgiref.local" ) def __getattr__(self, key): storage_object = self._data.get({}) try: return storage_object[key] except KeyError: raise AttributeError(f"{self!r} object has no attribute {key!r}") def __setattr__(self, key: str, value: Any) -> None: if key == "_data": return super().__setattr__(key, value) storage_object = self._data.get({}).copy() storage_object[key] = value self._data.set(storage_object) def __delattr__(self, key: str) -> None: storage_object = self._data.get({}).copy() if key in storage_object: del storage_object[key] self._data.set(storage_object) else: raise AttributeError(f"{self!r} object has no attribute {key!r}") class Local: """Local storage for async tasks. This is a namespace object (similar to `threading.local`) where data is also local to the current async task (if there is one). In async threads, local means in the same sense as the `contextvars` module - i.e. a value set in an async frame will be visible: - to other async code `await`-ed from this frame. - to tasks spawned using `asyncio` utilities (`create_task`, `wait_for`, `gather` and probably others). - to code scheduled in a sync thread using `sync_to_async` In "sync" threads (a thread with no async event loop running), the data is thread-local, but additionally shared with async code executed via the `async_to_sync` utility, which schedules async code in a new thread and copies context across to that thread. If `thread_critical` is True, then the local will only be visible per-thread, behaving exactly like `threading.local` if the thread is sync, and as `contextvars` if the thread is async. This allows genuinely thread-sensitive code (such as DB handles) to be kept stricly to their initial thread and disable the sharing across `sync_to_async` and `async_to_sync` wrapped calls. Unlike plain `contextvars` objects, this utility is threadsafe. """ def __init__(self, thread_critical: bool = False) -> None: self._thread_critical = thread_critical self._thread_lock = threading.RLock() self._storage: "Union[threading.local, _CVar]" if thread_critical: # Thread-local storage self._storage = threading.local() else: # Contextvar storage self._storage = _CVar() @contextlib.contextmanager def _lock_storage(self): # Thread safe access to storage if self._thread_critical: is_async = True try: # this is a test for are we in a async or sync # thread - will raise RuntimeError if there is # no current loop asyncio.get_running_loop() except RuntimeError: is_async = False if not is_async: # We are in a sync thread, the storage is # just the plain thread local (i.e, "global within # this thread" - it doesn't matter where you are # in a call stack you see the same storage) yield self._storage else: # We are in an async thread - storage is still # local to this thread, but additionally should # behave like a context var (is only visible with # the same async call stack) # Ensure context exists in the current thread if not hasattr(self._storage, "cvar"): self._storage.cvar = _CVar() # self._storage is a thread local, so the members # can't be accessed in another thread (we don't # need any locks) yield self._storage.cvar else: # Lock for thread_critical=False as other threads # can access the exact same storage object with self._thread_lock: yield self._storage def __getattr__(self, key): with self._lock_storage() as storage: return getattr(storage, key) def __setattr__(self, key, value): if key in ("_local", "_storage", "_thread_critical", "_thread_lock"): return super().__setattr__(key, value) with self._lock_storage() as storage: setattr(storage, key, value) def __delattr__(self, key): with self._lock_storage() as storage: delattr(storage, key) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1650354462.0 asgiref-3.9.2/asgiref/py.typed0000644000076500000240000000000014227464436015653 0ustar00carltonstaff././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1751534664.0 asgiref-3.9.2/asgiref/server.py0000644000076500000240000001424715031446110016035 0ustar00carltonstaffimport asyncio import logging import time import traceback from .compatibility import guarantee_single_callable logger = logging.getLogger(__name__) class StatelessServer: """ Base server class that handles basic concepts like application instance creation/pooling, exception handling, and similar, for stateless protocols (i.e. ones without actual incoming connections to the process) Your code should override the handle() method, doing whatever it needs to, and calling get_or_create_application_instance with a unique `scope_id` and `scope` for the scope it wants to get. If an application instance is found with the same `scope_id`, you are given its input queue, otherwise one is made for you with the scope provided and you are given that fresh new input queue. Either way, you should do something like: input_queue = self.get_or_create_application_instance( "user-123456", {"type": "testprotocol", "user_id": "123456", "username": "andrew"}, ) input_queue.put_nowait(message) If you try and create an application instance and there are already `max_application` instances, the oldest/least recently used one will be reclaimed and shut down to make space. Application coroutines that error will be found periodically (every 100ms by default) and have their exceptions printed to the console. Override application_exception() if you want to do more when this happens. If you override run(), make sure you handle things like launching the application checker. """ application_checker_interval = 0.1 def __init__(self, application, max_applications=1000): # Parameters self.application = application self.max_applications = max_applications # Initialisation self.application_instances = {} ### Mainloop and handling def run(self): """ Runs the asyncio event loop with our handler loop. """ event_loop = asyncio.get_event_loop() try: event_loop.run_until_complete(self.arun()) except KeyboardInterrupt: logger.info("Exiting due to Ctrl-C/interrupt") async def arun(self): """ Runs the asyncio event loop with our handler loop. """ class Done(Exception): pass async def handle(): await self.handle() raise Done try: await asyncio.gather(self.application_checker(), handle()) except Done: pass async def handle(self): raise NotImplementedError("You must implement handle()") async def application_send(self, scope, message): """ Receives outbound sends from applications and handles them. """ raise NotImplementedError("You must implement application_send()") ### Application instance management def get_or_create_application_instance(self, scope_id, scope): """ Creates an application instance and returns its queue. """ if scope_id in self.application_instances: self.application_instances[scope_id]["last_used"] = time.time() return self.application_instances[scope_id]["input_queue"] # See if we need to delete an old one while len(self.application_instances) > self.max_applications: self.delete_oldest_application_instance() # Make an instance of the application input_queue = asyncio.Queue() application_instance = guarantee_single_callable(self.application) # Run it, and stash the future for later checking future = asyncio.ensure_future( application_instance( scope=scope, receive=input_queue.get, send=lambda message: self.application_send(scope, message), ), ) self.application_instances[scope_id] = { "input_queue": input_queue, "future": future, "scope": scope, "last_used": time.time(), } return input_queue def delete_oldest_application_instance(self): """ Finds and deletes the oldest application instance """ oldest_time = min( details["last_used"] for details in self.application_instances.values() ) for scope_id, details in self.application_instances.items(): if details["last_used"] == oldest_time: self.delete_application_instance(scope_id) # Return to make sure we only delete one in case two have # the same oldest time return def delete_application_instance(self, scope_id): """ Removes an application instance (makes sure its task is stopped, then removes it from the current set) """ details = self.application_instances[scope_id] del self.application_instances[scope_id] if not details["future"].done(): details["future"].cancel() async def application_checker(self): """ Goes through the set of current application instance Futures and cleans up any that are done/prints exceptions for any that errored. """ while True: await asyncio.sleep(self.application_checker_interval) for scope_id, details in list(self.application_instances.items()): if details["future"].done(): exception = details["future"].exception() if exception: await self.application_exception(exception, details) try: del self.application_instances[scope_id] except KeyError: # Exception handling might have already got here before us. That's fine. pass async def application_exception(self, exception, application_details): """ Called whenever an application coroutine has an exception. """ logging.error( "Exception inside application: %s\n%s%s", exception, "".join(traceback.format_tb(exception.__traceback__)), f" {exception}", ) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1751534724.0 asgiref-3.9.2/asgiref/sync.py0000644000076500000240000004770115031446204015510 0ustar00carltonstaffimport asyncio import asyncio.coroutines import contextvars import functools import inspect import os import sys import threading import warnings import weakref from concurrent.futures import Future, ThreadPoolExecutor from typing import ( TYPE_CHECKING, Any, Awaitable, Callable, Coroutine, Dict, Generic, List, Optional, TypeVar, Union, overload, ) from .current_thread_executor import CurrentThreadExecutor from .local import Local if sys.version_info >= (3, 10): from typing import ParamSpec else: from typing_extensions import ParamSpec if TYPE_CHECKING: # This is not available to import at runtime from _typeshed import OptExcInfo _F = TypeVar("_F", bound=Callable[..., Any]) _P = ParamSpec("_P") _R = TypeVar("_R") def _restore_context(context: contextvars.Context) -> None: # Check for changes in contextvars, and set them to the current # context for downstream consumers for cvar in context: cvalue = context.get(cvar) try: if cvar.get() != cvalue: cvar.set(cvalue) except LookupError: cvar.set(cvalue) # Python 3.12 deprecates asyncio.iscoroutinefunction() as an alias for # inspect.iscoroutinefunction(), whilst also removing the _is_coroutine marker. # The latter is replaced with the inspect.markcoroutinefunction decorator. # Until 3.12 is the minimum supported Python version, provide a shim. if hasattr(inspect, "markcoroutinefunction"): iscoroutinefunction = inspect.iscoroutinefunction markcoroutinefunction: Callable[[_F], _F] = inspect.markcoroutinefunction else: iscoroutinefunction = asyncio.iscoroutinefunction # type: ignore[assignment] def markcoroutinefunction(func: _F) -> _F: func._is_coroutine = asyncio.coroutines._is_coroutine # type: ignore return func class ThreadSensitiveContext: """Async context manager to manage context for thread sensitive mode This context manager controls which thread pool executor is used when in thread sensitive mode. By default, a single thread pool executor is shared within a process. The ThreadSensitiveContext() context manager may be used to specify a thread pool per context. This context manager is re-entrant, so only the outer-most call to ThreadSensitiveContext will set the context. Usage: >>> import time >>> async with ThreadSensitiveContext(): ... await sync_to_async(time.sleep, 1)() """ def __init__(self): self.token = None async def __aenter__(self): try: SyncToAsync.thread_sensitive_context.get() except LookupError: self.token = SyncToAsync.thread_sensitive_context.set(self) return self async def __aexit__(self, exc, value, tb): if not self.token: return executor = SyncToAsync.context_to_thread_executor.pop(self, None) if executor: executor.shutdown() SyncToAsync.thread_sensitive_context.reset(self.token) class AsyncToSync(Generic[_P, _R]): """ Utility class which turns an awaitable that only works on the thread with the event loop into a synchronous callable that works in a subthread. If the call stack contains an async loop, the code runs there. Otherwise, the code runs in a new loop in a new thread. Either way, this thread then pauses and waits to run any thread_sensitive code called from further down the call stack using SyncToAsync, before finally exiting once the async task returns. """ # Keeps a reference to the CurrentThreadExecutor in local context, so that # any sync_to_async inside the wrapped code can find it. executors: "Local" = Local() # When we can't find a CurrentThreadExecutor from the context, such as # inside create_task, we'll look it up here from the running event loop. loop_thread_executors: "Dict[asyncio.AbstractEventLoop, CurrentThreadExecutor]" = {} def __init__( self, awaitable: Union[ Callable[_P, Coroutine[Any, Any, _R]], Callable[_P, Awaitable[_R]], ], force_new_loop: bool = False, ): if not callable(awaitable) or ( not iscoroutinefunction(awaitable) and not iscoroutinefunction(getattr(awaitable, "__call__", awaitable)) ): # Python does not have very reliable detection of async functions # (lots of false negatives) so this is just a warning. warnings.warn( "async_to_sync was passed a non-async-marked callable", stacklevel=2 ) self.awaitable = awaitable try: self.__self__ = self.awaitable.__self__ # type: ignore[union-attr] except AttributeError: pass self.force_new_loop = force_new_loop self.main_event_loop = None try: self.main_event_loop = asyncio.get_running_loop() except RuntimeError: # There's no event loop in this thread. pass def __call__(self, *args: _P.args, **kwargs: _P.kwargs) -> _R: __traceback_hide__ = True # noqa: F841 if not self.force_new_loop and not self.main_event_loop: # There's no event loop in this thread. Look for the threadlocal if # we're inside SyncToAsync main_event_loop_pid = getattr( SyncToAsync.threadlocal, "main_event_loop_pid", None ) # We make sure the parent loop is from the same process - if # they've forked, this is not going to be valid any more (#194) if main_event_loop_pid and main_event_loop_pid == os.getpid(): self.main_event_loop = getattr( SyncToAsync.threadlocal, "main_event_loop", None ) # You can't call AsyncToSync from a thread with a running event loop try: asyncio.get_running_loop() except RuntimeError: pass else: raise RuntimeError( "You cannot use AsyncToSync in the same thread as an async event loop - " "just await the async function directly." ) # Make a future for the return information call_result: "Future[_R]" = Future() # Make a CurrentThreadExecutor we'll use to idle in this thread - we # need one for every sync frame, even if there's one above us in the # same thread. old_executor = getattr(self.executors, "current", None) current_executor = CurrentThreadExecutor(old_executor) self.executors.current = current_executor # Wrapping context in list so it can be reassigned from within # `main_wrap`. context = [contextvars.copy_context()] # Get task context so that parent task knows which task to propagate # an asyncio.CancelledError to. task_context = getattr(SyncToAsync.threadlocal, "task_context", None) # Use call_soon_threadsafe to schedule a synchronous callback on the # main event loop's thread if it's there, otherwise make a new loop # in this thread. try: awaitable = self.main_wrap( call_result, sys.exc_info(), task_context, context, # prepare an awaitable which can be passed as is to self.main_wrap, # so that `args` and `kwargs` don't need to be # destructured when passed to self.main_wrap # (which is required by `ParamSpec`) # as that may cause overlapping arguments self.awaitable(*args, **kwargs), ) async def new_loop_wrap() -> None: loop = asyncio.get_running_loop() self.loop_thread_executors[loop] = current_executor try: await awaitable finally: del self.loop_thread_executors[loop] if self.main_event_loop is not None: try: self.main_event_loop.call_soon_threadsafe( self.main_event_loop.create_task, awaitable ) except RuntimeError: running_in_main_event_loop = False else: running_in_main_event_loop = True # Run the CurrentThreadExecutor until the future is done. current_executor.run_until_future(call_result) else: running_in_main_event_loop = False if not running_in_main_event_loop: # Make our own event loop - in a new thread - and run inside that. loop_executor = ThreadPoolExecutor(max_workers=1) loop_future = loop_executor.submit(asyncio.run, new_loop_wrap()) # Run the CurrentThreadExecutor until the future is done. current_executor.run_until_future(loop_future) # Wait for future and/or allow for exception propagation loop_future.result() finally: _restore_context(context[0]) # Restore old current thread executor state self.executors.current = old_executor # Wait for results from the future. return call_result.result() def __get__(self, parent: Any, objtype: Any) -> Callable[_P, _R]: """ Include self for methods """ func = functools.partial(self.__call__, parent) return functools.update_wrapper(func, self.awaitable) async def main_wrap( self, call_result: "Future[_R]", exc_info: "OptExcInfo", task_context: "Optional[List[asyncio.Task[Any]]]", context: List[contextvars.Context], awaitable: Union[Coroutine[Any, Any, _R], Awaitable[_R]], ) -> None: """ Wraps the awaitable with something that puts the result into the result/exception future. """ __traceback_hide__ = True # noqa: F841 if context is not None: _restore_context(context[0]) current_task = asyncio.current_task() if current_task is not None and task_context is not None: task_context.append(current_task) try: # If we have an exception, run the function inside the except block # after raising it so exc_info is correctly populated. if exc_info[1]: try: raise exc_info[1] except BaseException: result = await awaitable else: result = await awaitable except BaseException as e: call_result.set_exception(e) else: call_result.set_result(result) finally: if current_task is not None and task_context is not None: task_context.remove(current_task) context[0] = contextvars.copy_context() class SyncToAsync(Generic[_P, _R]): """ Utility class which turns a synchronous callable into an awaitable that runs in a threadpool. It also sets a threadlocal inside the thread so calls to AsyncToSync can escape it. If thread_sensitive is passed, the code will run in the same thread as any outer code. This is needed for underlying Python code that is not threadsafe (for example, code which handles SQLite database connections). If the outermost program is async (i.e. SyncToAsync is outermost), then this will be a dedicated single sub-thread that all sync code runs in, one after the other. If the outermost program is sync (i.e. AsyncToSync is outermost), this will just be the main thread. This is achieved by idling with a CurrentThreadExecutor while AsyncToSync is blocking its sync parent, rather than just blocking. If executor is passed in, that will be used instead of the loop's default executor. In order to pass in an executor, thread_sensitive must be set to False, otherwise a TypeError will be raised. """ # Storage for main event loop references threadlocal = threading.local() # Single-thread executor for thread-sensitive code single_thread_executor = ThreadPoolExecutor(max_workers=1) # Maintain a contextvar for the current execution context. Optionally used # for thread sensitive mode. thread_sensitive_context: "contextvars.ContextVar[ThreadSensitiveContext]" = ( contextvars.ContextVar("thread_sensitive_context") ) # Contextvar that is used to detect if the single thread executor # would be awaited on while already being used in the same context deadlock_context: "contextvars.ContextVar[bool]" = contextvars.ContextVar( "deadlock_context" ) # Maintaining a weak reference to the context ensures that thread pools are # erased once the context goes out of scope. This terminates the thread pool. context_to_thread_executor: "weakref.WeakKeyDictionary[ThreadSensitiveContext, ThreadPoolExecutor]" = ( weakref.WeakKeyDictionary() ) def __init__( self, func: Callable[_P, _R], thread_sensitive: bool = True, executor: Optional["ThreadPoolExecutor"] = None, ) -> None: if ( not callable(func) or iscoroutinefunction(func) or iscoroutinefunction(getattr(func, "__call__", func)) ): raise TypeError("sync_to_async can only be applied to sync functions.") self.func = func functools.update_wrapper(self, func) self._thread_sensitive = thread_sensitive markcoroutinefunction(self) if thread_sensitive and executor is not None: raise TypeError("executor must not be set when thread_sensitive is True") self._executor = executor try: self.__self__ = func.__self__ # type: ignore except AttributeError: pass async def __call__(self, *args: _P.args, **kwargs: _P.kwargs) -> _R: __traceback_hide__ = True # noqa: F841 loop = asyncio.get_running_loop() # Work out what thread to run the code in if self._thread_sensitive: current_thread_executor = getattr(AsyncToSync.executors, "current", None) if current_thread_executor: # If we have a parent sync thread above somewhere, use that executor = current_thread_executor elif self.thread_sensitive_context.get(None): # If we have a way of retrieving the current context, attempt # to use a per-context thread pool executor thread_sensitive_context = self.thread_sensitive_context.get() if thread_sensitive_context in self.context_to_thread_executor: # Re-use thread executor in current context executor = self.context_to_thread_executor[thread_sensitive_context] else: # Create new thread executor in current context executor = ThreadPoolExecutor(max_workers=1) self.context_to_thread_executor[thread_sensitive_context] = executor elif loop in AsyncToSync.loop_thread_executors: # Re-use thread executor for running loop executor = AsyncToSync.loop_thread_executors[loop] elif self.deadlock_context.get(False): raise RuntimeError( "Single thread executor already being used, would deadlock" ) else: # Otherwise, we run it in a fixed single thread executor = self.single_thread_executor self.deadlock_context.set(True) else: # Use the passed in executor, or the loop's default if it is None executor = self._executor context = contextvars.copy_context() child = functools.partial(self.func, *args, **kwargs) func = context.run task_context: List[asyncio.Task[Any]] = [] # Run the code in the right thread exec_coro = loop.run_in_executor( executor, functools.partial( self.thread_handler, loop, sys.exc_info(), task_context, func, child, ), ) ret: _R try: ret = await asyncio.shield(exec_coro) except asyncio.CancelledError: cancel_parent = True try: task = task_context[0] task.cancel() try: await task cancel_parent = False except asyncio.CancelledError: pass except IndexError: pass if exec_coro.done(): raise if cancel_parent: exec_coro.cancel() ret = await exec_coro finally: _restore_context(context) self.deadlock_context.set(False) return ret def __get__( self, parent: Any, objtype: Any ) -> Callable[_P, Coroutine[Any, Any, _R]]: """ Include self for methods """ func = functools.partial(self.__call__, parent) return functools.update_wrapper(func, self.func) def thread_handler(self, loop, exc_info, task_context, func, *args, **kwargs): """ Wraps the sync application with exception handling. """ __traceback_hide__ = True # noqa: F841 # Set the threadlocal for AsyncToSync self.threadlocal.main_event_loop = loop self.threadlocal.main_event_loop_pid = os.getpid() self.threadlocal.task_context = task_context # Run the function # If we have an exception, run the function inside the except block # after raising it so exc_info is correctly populated. if exc_info[1]: try: raise exc_info[1] except BaseException: return func(*args, **kwargs) else: return func(*args, **kwargs) @overload def async_to_sync( *, force_new_loop: bool = False, ) -> Callable[ [Union[Callable[_P, Coroutine[Any, Any, _R]], Callable[_P, Awaitable[_R]]]], Callable[_P, _R], ]: ... @overload def async_to_sync( awaitable: Union[ Callable[_P, Coroutine[Any, Any, _R]], Callable[_P, Awaitable[_R]], ], *, force_new_loop: bool = False, ) -> Callable[_P, _R]: ... def async_to_sync( awaitable: Optional[ Union[ Callable[_P, Coroutine[Any, Any, _R]], Callable[_P, Awaitable[_R]], ] ] = None, *, force_new_loop: bool = False, ) -> Union[ Callable[ [Union[Callable[_P, Coroutine[Any, Any, _R]], Callable[_P, Awaitable[_R]]]], Callable[_P, _R], ], Callable[_P, _R], ]: if awaitable is None: return lambda f: AsyncToSync( f, force_new_loop=force_new_loop, ) return AsyncToSync( awaitable, force_new_loop=force_new_loop, ) @overload def sync_to_async( *, thread_sensitive: bool = True, executor: Optional["ThreadPoolExecutor"] = None, ) -> Callable[[Callable[_P, _R]], Callable[_P, Coroutine[Any, Any, _R]]]: ... @overload def sync_to_async( func: Callable[_P, _R], *, thread_sensitive: bool = True, executor: Optional["ThreadPoolExecutor"] = None, ) -> Callable[_P, Coroutine[Any, Any, _R]]: ... def sync_to_async( func: Optional[Callable[_P, _R]] = None, *, thread_sensitive: bool = True, executor: Optional["ThreadPoolExecutor"] = None, ) -> Union[ Callable[[Callable[_P, _R]], Callable[_P, Coroutine[Any, Any, _R]]], Callable[_P, Coroutine[Any, Any, _R]], ]: if func is None: return lambda f: SyncToAsync( f, thread_sensitive=thread_sensitive, executor=executor, ) return SyncToAsync( func, thread_sensitive=thread_sensitive, executor=executor, ) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1751534664.0 asgiref-3.9.2/asgiref/testing.py0000644000076500000240000001050515031446110016175 0ustar00carltonstaffimport asyncio import contextvars import time from .compatibility import guarantee_single_callable from .timeout import timeout as async_timeout class ApplicationCommunicator: """ Runs an ASGI application in a test mode, allowing sending of messages to it and retrieval of messages it sends. """ def __init__(self, application, scope): self._future = None self.application = guarantee_single_callable(application) self.scope = scope self._input_queue = None self._output_queue = None # For Python 3.9 we need to lazily bind the queues, on 3.10+ they bind the # event loop lazily. @property def input_queue(self): if self._input_queue is None: self._input_queue = asyncio.Queue() return self._input_queue @property def output_queue(self): if self._output_queue is None: self._output_queue = asyncio.Queue() return self._output_queue @property def future(self): if self._future is None: # Clear context - this ensures that context vars set in the testing scope # are not "leaked" into the application which would normally begin with # an empty context. In Python >= 3.11 this could also be written as: # asyncio.create_task(..., context=contextvars.Context()) self._future = contextvars.Context().run( asyncio.create_task, self.application( self.scope, self.input_queue.get, self.output_queue.put ), ) return self._future async def wait(self, timeout=1): """ Waits for the application to stop itself and returns any exceptions. """ try: async with async_timeout(timeout): try: await self.future self.future.result() except asyncio.CancelledError: pass finally: if not self.future.done(): self.future.cancel() try: await self.future except asyncio.CancelledError: pass def stop(self, exceptions=True): future = self._future if future is None: return if not future.done(): future.cancel() elif exceptions: # Give a chance to raise any exceptions future.result() def __del__(self): # Clean up on deletion try: self.stop(exceptions=False) except RuntimeError: # Event loop already stopped pass async def send_input(self, message): """ Sends a single message to the application """ # Make sure there's not an exception to raise from the task if self.future.done(): self.future.result() # Give it the message await self.input_queue.put(message) async def receive_output(self, timeout=1): """ Receives a single message from the application, with optional timeout. """ # Make sure there's not an exception to raise from the task if self.future.done(): self.future.result() # Wait and receive the message try: async with async_timeout(timeout): return await self.output_queue.get() except asyncio.TimeoutError as e: # See if we have another error to raise inside if self.future.done(): self.future.result() else: self.future.cancel() try: await self.future except asyncio.CancelledError: pass raise e async def receive_nothing(self, timeout=0.1, interval=0.01): """ Checks that there is no message to receive in the given time. """ # Make sure there's not an exception to raise from the task if self.future.done(): self.future.result() # `interval` has precedence over `timeout` start = time.monotonic() while time.monotonic() - start < timeout: if not self.output_queue.empty(): return False await asyncio.sleep(interval) return self.output_queue.empty() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1671129208.0 asgiref-3.9.2/asgiref/timeout.py0000644000076500000240000000705314346664170016232 0ustar00carltonstaff# This code is originally sourced from the aio-libs project "async_timeout", # under the Apache 2.0 license. You may see the original project at # https://github.com/aio-libs/async-timeout # It is vendored here to reduce chain-dependencies on this library, and # modified slightly to remove some features we don't use. import asyncio import warnings from types import TracebackType from typing import Any # noqa from typing import Optional, Type class timeout: """timeout context manager. Useful in cases when you want to apply timeout logic around block of code or in cases when asyncio.wait_for is not suitable. For example: >>> with timeout(0.001): ... async with aiohttp.get('https://github.com') as r: ... await r.text() timeout - value in seconds or None to disable timeout logic loop - asyncio compatible event loop """ def __init__( self, timeout: Optional[float], *, loop: Optional[asyncio.AbstractEventLoop] = None, ) -> None: self._timeout = timeout if loop is None: loop = asyncio.get_running_loop() else: warnings.warn( """The loop argument to timeout() is deprecated.""", DeprecationWarning ) self._loop = loop self._task = None # type: Optional[asyncio.Task[Any]] self._cancelled = False self._cancel_handler = None # type: Optional[asyncio.Handle] self._cancel_at = None # type: Optional[float] def __enter__(self) -> "timeout": return self._do_enter() def __exit__( self, exc_type: Type[BaseException], exc_val: BaseException, exc_tb: TracebackType, ) -> Optional[bool]: self._do_exit(exc_type) return None async def __aenter__(self) -> "timeout": return self._do_enter() async def __aexit__( self, exc_type: Type[BaseException], exc_val: BaseException, exc_tb: TracebackType, ) -> None: self._do_exit(exc_type) @property def expired(self) -> bool: return self._cancelled @property def remaining(self) -> Optional[float]: if self._cancel_at is not None: return max(self._cancel_at - self._loop.time(), 0.0) else: return None def _do_enter(self) -> "timeout": # Support Tornado 5- without timeout # Details: https://github.com/python/asyncio/issues/392 if self._timeout is None: return self self._task = asyncio.current_task(self._loop) if self._task is None: raise RuntimeError( "Timeout context manager should be used " "inside a task" ) if self._timeout <= 0: self._loop.call_soon(self._cancel_task) return self self._cancel_at = self._loop.time() + self._timeout self._cancel_handler = self._loop.call_at(self._cancel_at, self._cancel_task) return self def _do_exit(self, exc_type: Type[BaseException]) -> None: if exc_type is asyncio.CancelledError and self._cancelled: self._cancel_handler = None self._task = None raise asyncio.TimeoutError if self._timeout is not None and self._cancel_handler is not None: self._cancel_handler.cancel() self._cancel_handler = None self._task = None return None def _cancel_task(self) -> None: if self._task is not None: self._task.cancel() self._cancelled = True ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1733559318.0 asgiref-3.9.2/asgiref/typing.py0000644000076500000240000001422214725002026016035 0ustar00carltonstaffimport sys from typing import ( Any, Awaitable, Callable, Dict, Iterable, Literal, Optional, Protocol, Tuple, Type, TypedDict, Union, ) if sys.version_info >= (3, 11): from typing import NotRequired else: from typing_extensions import NotRequired __all__ = ( "ASGIVersions", "HTTPScope", "WebSocketScope", "LifespanScope", "WWWScope", "Scope", "HTTPRequestEvent", "HTTPResponseStartEvent", "HTTPResponseBodyEvent", "HTTPResponseTrailersEvent", "HTTPResponsePathsendEvent", "HTTPServerPushEvent", "HTTPDisconnectEvent", "WebSocketConnectEvent", "WebSocketAcceptEvent", "WebSocketReceiveEvent", "WebSocketSendEvent", "WebSocketResponseStartEvent", "WebSocketResponseBodyEvent", "WebSocketDisconnectEvent", "WebSocketCloseEvent", "LifespanStartupEvent", "LifespanShutdownEvent", "LifespanStartupCompleteEvent", "LifespanStartupFailedEvent", "LifespanShutdownCompleteEvent", "LifespanShutdownFailedEvent", "ASGIReceiveEvent", "ASGISendEvent", "ASGIReceiveCallable", "ASGISendCallable", "ASGI2Protocol", "ASGI2Application", "ASGI3Application", "ASGIApplication", ) class ASGIVersions(TypedDict): spec_version: str version: Union[Literal["2.0"], Literal["3.0"]] class HTTPScope(TypedDict): type: Literal["http"] asgi: ASGIVersions http_version: str method: str scheme: str path: str raw_path: bytes query_string: bytes root_path: str headers: Iterable[Tuple[bytes, bytes]] client: Optional[Tuple[str, int]] server: Optional[Tuple[str, Optional[int]]] state: NotRequired[Dict[str, Any]] extensions: Optional[Dict[str, Dict[object, object]]] class WebSocketScope(TypedDict): type: Literal["websocket"] asgi: ASGIVersions http_version: str scheme: str path: str raw_path: bytes query_string: bytes root_path: str headers: Iterable[Tuple[bytes, bytes]] client: Optional[Tuple[str, int]] server: Optional[Tuple[str, Optional[int]]] subprotocols: Iterable[str] state: NotRequired[Dict[str, Any]] extensions: Optional[Dict[str, Dict[object, object]]] class LifespanScope(TypedDict): type: Literal["lifespan"] asgi: ASGIVersions state: NotRequired[Dict[str, Any]] WWWScope = Union[HTTPScope, WebSocketScope] Scope = Union[HTTPScope, WebSocketScope, LifespanScope] class HTTPRequestEvent(TypedDict): type: Literal["http.request"] body: bytes more_body: bool class HTTPResponseDebugEvent(TypedDict): type: Literal["http.response.debug"] info: Dict[str, object] class HTTPResponseStartEvent(TypedDict): type: Literal["http.response.start"] status: int headers: Iterable[Tuple[bytes, bytes]] trailers: bool class HTTPResponseBodyEvent(TypedDict): type: Literal["http.response.body"] body: bytes more_body: bool class HTTPResponseTrailersEvent(TypedDict): type: Literal["http.response.trailers"] headers: Iterable[Tuple[bytes, bytes]] more_trailers: bool class HTTPResponsePathsendEvent(TypedDict): type: Literal["http.response.pathsend"] path: str class HTTPServerPushEvent(TypedDict): type: Literal["http.response.push"] path: str headers: Iterable[Tuple[bytes, bytes]] class HTTPDisconnectEvent(TypedDict): type: Literal["http.disconnect"] class WebSocketConnectEvent(TypedDict): type: Literal["websocket.connect"] class WebSocketAcceptEvent(TypedDict): type: Literal["websocket.accept"] subprotocol: Optional[str] headers: Iterable[Tuple[bytes, bytes]] class WebSocketReceiveEvent(TypedDict): type: Literal["websocket.receive"] bytes: Optional[bytes] text: Optional[str] class WebSocketSendEvent(TypedDict): type: Literal["websocket.send"] bytes: Optional[bytes] text: Optional[str] class WebSocketResponseStartEvent(TypedDict): type: Literal["websocket.http.response.start"] status: int headers: Iterable[Tuple[bytes, bytes]] class WebSocketResponseBodyEvent(TypedDict): type: Literal["websocket.http.response.body"] body: bytes more_body: bool class WebSocketDisconnectEvent(TypedDict): type: Literal["websocket.disconnect"] code: int reason: Optional[str] class WebSocketCloseEvent(TypedDict): type: Literal["websocket.close"] code: int reason: Optional[str] class LifespanStartupEvent(TypedDict): type: Literal["lifespan.startup"] class LifespanShutdownEvent(TypedDict): type: Literal["lifespan.shutdown"] class LifespanStartupCompleteEvent(TypedDict): type: Literal["lifespan.startup.complete"] class LifespanStartupFailedEvent(TypedDict): type: Literal["lifespan.startup.failed"] message: str class LifespanShutdownCompleteEvent(TypedDict): type: Literal["lifespan.shutdown.complete"] class LifespanShutdownFailedEvent(TypedDict): type: Literal["lifespan.shutdown.failed"] message: str ASGIReceiveEvent = Union[ HTTPRequestEvent, HTTPDisconnectEvent, WebSocketConnectEvent, WebSocketReceiveEvent, WebSocketDisconnectEvent, LifespanStartupEvent, LifespanShutdownEvent, ] ASGISendEvent = Union[ HTTPResponseStartEvent, HTTPResponseBodyEvent, HTTPResponseTrailersEvent, HTTPServerPushEvent, HTTPDisconnectEvent, WebSocketAcceptEvent, WebSocketSendEvent, WebSocketResponseStartEvent, WebSocketResponseBodyEvent, WebSocketCloseEvent, LifespanStartupCompleteEvent, LifespanStartupFailedEvent, LifespanShutdownCompleteEvent, LifespanShutdownFailedEvent, ] ASGIReceiveCallable = Callable[[], Awaitable[ASGIReceiveEvent]] ASGISendCallable = Callable[[ASGISendEvent], Awaitable[None]] class ASGI2Protocol(Protocol): def __init__(self, scope: Scope) -> None: ... async def __call__( self, receive: ASGIReceiveCallable, send: ASGISendCallable ) -> None: ... ASGI2Application = Type[ASGI2Protocol] ASGI3Application = Callable[ [ Scope, ASGIReceiveCallable, ASGISendCallable, ], Awaitable[None], ] ASGIApplication = Union[ASGI2Application, ASGI3Application] ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1758635742.0 asgiref-3.9.2/asgiref/wsgi.py0000644000076500000240000001512615064523336015511 0ustar00carltonstaffimport sys from tempfile import SpooledTemporaryFile from asgiref.sync import AsyncToSync, sync_to_async class WsgiToAsgi: """ Wraps a WSGI application to make it into an ASGI application. """ def __init__(self, wsgi_application): self.wsgi_application = wsgi_application async def __call__(self, scope, receive, send): """ ASGI application instantiation point. We return a new WsgiToAsgiInstance here with the WSGI app and the scope, ready to respond when it is __call__ed. """ await WsgiToAsgiInstance(self.wsgi_application)(scope, receive, send) class WsgiToAsgiInstance: """ Per-socket instance of a wrapped WSGI application """ def __init__(self, wsgi_application): self.wsgi_application = wsgi_application self.response_started = False self.response_content_length = None async def __call__(self, scope, receive, send): if scope["type"] != "http": raise ValueError("WSGI wrapper received a non-HTTP scope") self.scope = scope with SpooledTemporaryFile(max_size=65536) as body: # Alright, wait for the http.request messages while True: message = await receive() if message["type"] != "http.request": raise ValueError("WSGI wrapper received a non-HTTP-request message") body.write(message.get("body", b"")) if not message.get("more_body"): break body.seek(0) # Wrap send so it can be called from the subthread self.sync_send = AsyncToSync(send) # Call the WSGI app await self.run_wsgi_app(body) def build_environ(self, scope, body): """ Builds a scope and request body into a WSGI environ object. """ script_name = scope.get("root_path", "").encode("utf8").decode("latin1") path_info = scope["path"].encode("utf8").decode("latin1") if path_info.startswith(script_name): path_info = path_info[len(script_name) :] environ = { "REQUEST_METHOD": scope["method"], "SCRIPT_NAME": script_name, "PATH_INFO": path_info, "QUERY_STRING": scope["query_string"].decode("ascii"), "SERVER_PROTOCOL": "HTTP/%s" % scope["http_version"], "wsgi.version": (1, 0), "wsgi.url_scheme": scope.get("scheme", "http"), "wsgi.input": body, "wsgi.errors": sys.stderr, "wsgi.multithread": True, "wsgi.multiprocess": True, "wsgi.run_once": False, } # Get server name and port - required in WSGI, not in ASGI if "server" in scope: environ["SERVER_NAME"] = scope["server"][0] environ["SERVER_PORT"] = str(scope["server"][1]) else: environ["SERVER_NAME"] = "localhost" environ["SERVER_PORT"] = "80" if scope.get("client") is not None: environ["REMOTE_ADDR"] = scope["client"][0] # Go through headers and make them into environ entries for name, value in self.scope.get("headers", []): name = name.decode("latin1") if name == "content-length": corrected_name = "CONTENT_LENGTH" elif name == "content-type": corrected_name = "CONTENT_TYPE" else: corrected_name = "HTTP_%s" % name.upper().replace("-", "_") # HTTPbis say only ASCII chars are allowed in headers, but we latin1 just in case value = value.decode("latin1") if corrected_name in environ: value = environ[corrected_name] + "," + value environ[corrected_name] = value return environ def start_response(self, status, response_headers, exc_info=None): """ WSGI start_response callable. """ # Don't allow re-calling once response has begun if self.response_started: raise exc_info[1].with_traceback(exc_info[2]) # Don't allow re-calling without exc_info if hasattr(self, "response_start") and exc_info is None: raise ValueError( "You cannot call start_response a second time without exc_info" ) # Extract status code status_code, _ = status.split(" ", 1) status_code = int(status_code) # Extract headers headers = [ (name.lower().encode("ascii"), value.encode("ascii")) for name, value in response_headers ] # Extract content-length self.response_content_length = None for name, value in response_headers: if name.lower() == "content-length": self.response_content_length = int(value) # Build and send response start message. self.response_start = { "type": "http.response.start", "status": status_code, "headers": headers, } @sync_to_async def run_wsgi_app(self, body): """ Called in a subthread to run the WSGI app. We encapsulate like this so that the start_response callable is called in the same thread. """ # Translate the scope and incoming request body into a WSGI environ environ = self.build_environ(self.scope, body) # Run the WSGI app bytes_sent = 0 for output in self.wsgi_application(environ, self.start_response): # If this is the first response, include the response headers if not self.response_started: self.response_started = True self.sync_send(self.response_start) # If the application supplies a Content-Length header if self.response_content_length is not None: # The server should not transmit more bytes to the client than the header allows bytes_allowed = self.response_content_length - bytes_sent if len(output) > bytes_allowed: output = output[:bytes_allowed] self.sync_send( {"type": "http.response.body", "body": output, "more_body": True} ) bytes_sent += len(output) # The server should stop iterating over the response when enough data has been sent if bytes_sent == self.response_content_length: break # Close connection if not self.response_started: self.response_started = True self.sync_send(self.response_start) self.sync_send({"type": "http.response.body"}) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1758639645.9721477 asgiref-3.9.2/asgiref.egg-info/0000755000076500000240000000000015064533036015651 5ustar00carltonstaff././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1758639645.0 asgiref-3.9.2/asgiref.egg-info/PKG-INFO0000644000076500000240000002210615064533035016746 0ustar00carltonstaffMetadata-Version: 2.4 Name: asgiref Version: 3.9.2 Summary: ASGI specs, helper code, and adapters Home-page: https://github.com/django/asgiref/ Author: Django Software Foundation Author-email: foundation@djangoproject.com License: BSD-3-Clause Project-URL: Documentation, https://asgi.readthedocs.io/ Project-URL: Further Documentation, https://docs.djangoproject.com/en/stable/topics/async/#async-adapter-functions Project-URL: Changelog, https://github.com/django/asgiref/blob/master/CHANGELOG.txt Classifier: Development Status :: 5 - Production/Stable Classifier: Environment :: Web Environment Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: BSD License Classifier: Operating System :: OS Independent Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3 :: Only Classifier: Programming Language :: Python :: 3.9 Classifier: Programming Language :: Python :: 3.10 Classifier: Programming Language :: Python :: 3.11 Classifier: Programming Language :: Python :: 3.12 Classifier: Programming Language :: Python :: 3.13 Classifier: Topic :: Internet :: WWW/HTTP Requires-Python: >=3.9 License-File: LICENSE Requires-Dist: typing_extensions>=4; python_version < "3.11" Provides-Extra: tests Requires-Dist: pytest; extra == "tests" Requires-Dist: pytest-asyncio; extra == "tests" Requires-Dist: mypy>=1.14.0; extra == "tests" Dynamic: license-file asgiref ======= .. image:: https://github.com/django/asgiref/actions/workflows/tests.yml/badge.svg :target: https://github.com/django/asgiref/actions/workflows/tests.yml .. image:: https://img.shields.io/pypi/v/asgiref.svg :target: https://pypi.python.org/pypi/asgiref ASGI is a standard for Python asynchronous web apps and servers to communicate with each other, and positioned as an asynchronous successor to WSGI. You can read more at https://asgi.readthedocs.io/en/latest/ This package includes ASGI base libraries, such as: * Sync-to-async and async-to-sync function wrappers, ``asgiref.sync`` * Server base classes, ``asgiref.server`` * A WSGI-to-ASGI adapter, in ``asgiref.wsgi`` Function wrappers ----------------- These allow you to wrap or decorate async or sync functions to call them from the other style (so you can call async functions from a synchronous thread, or vice-versa). In particular: * AsyncToSync lets a synchronous subthread stop and wait while the async function is called on the main thread's event loop, and then control is returned to the thread when the async function is finished. * SyncToAsync lets async code call a synchronous function, which is run in a threadpool and control returned to the async coroutine when the synchronous function completes. The idea is to make it easier to call synchronous APIs from async code and asynchronous APIs from synchronous code so it's easier to transition code from one style to the other. In the case of Channels, we wrap the (synchronous) Django view system with SyncToAsync to allow it to run inside the (asynchronous) ASGI server. Note that exactly what threads things run in is very specific, and aimed to keep maximum compatibility with old synchronous code. See "Synchronous code & Threads" below for a full explanation. By default, ``sync_to_async`` will run all synchronous code in the program in the same thread for safety reasons; you can disable this for more performance with ``@sync_to_async(thread_sensitive=False)``, but make sure that your code does not rely on anything bound to threads (like database connections) when you do. Threadlocal replacement ----------------------- This is a drop-in replacement for ``threading.local`` that works with both threads and asyncio Tasks. Even better, it will proxy values through from a task-local context to a thread-local context when you use ``sync_to_async`` to run things in a threadpool, and vice-versa for ``async_to_sync``. If you instead want true thread- and task-safety, you can set ``thread_critical`` on the Local object to ensure this instead. Server base classes ------------------- Includes a ``StatelessServer`` class which provides all the hard work of writing a stateless server (as in, does not handle direct incoming sockets but instead consumes external streams or sockets to work out what is happening). An example of such a server would be a chatbot server that connects out to a central chat server and provides a "connection scope" per user chatting to it. There's only one actual connection, but the server has to separate things into several scopes for easier writing of the code. You can see an example of this being used in `frequensgi `_. WSGI-to-ASGI adapter -------------------- Allows you to wrap a WSGI application so it appears as a valid ASGI application. Simply wrap it around your WSGI application like so:: asgi_application = WsgiToAsgi(wsgi_application) The WSGI application will be run in a synchronous threadpool, and the wrapped ASGI application will be one that accepts ``http`` class messages. Please note that not all extended features of WSGI may be supported (such as file handles for incoming POST bodies). Dependencies ------------ ``asgiref`` requires Python 3.9 or higher. Contributing ------------ Please refer to the `main Channels contributing docs `_. Testing ''''''' To run tests, make sure you have installed the ``tests`` extra with the package:: cd asgiref/ pip install -e .[tests] pytest Building the documentation '''''''''''''''''''''''''' The documentation uses `Sphinx `_:: cd asgiref/docs/ pip install sphinx To build the docs, you can use the default tools:: sphinx-build -b html . _build/html # or `make html`, if you've got make set up cd _build/html python -m http.server ...or you can use ``sphinx-autobuild`` to run a server and rebuild/reload your documentation changes automatically:: pip install sphinx-autobuild sphinx-autobuild . _build/html Releasing ''''''''' To release, first add details to CHANGELOG.txt and update the version number in ``asgiref/__init__.py``. Then, build and push the packages:: python -m build twine upload dist/* rm -r asgiref.egg-info dist Implementation Details ---------------------- Synchronous code & threads '''''''''''''''''''''''''' The ``asgiref.sync`` module provides two wrappers that let you go between asynchronous and synchronous code at will, while taking care of the rough edges for you. Unfortunately, the rough edges are numerous, and the code has to work especially hard to keep things in the same thread as much as possible. Notably, the restrictions we are working with are: * All synchronous code called through ``SyncToAsync`` and marked with ``thread_sensitive`` should run in the same thread as each other (and if the outer layer of the program is synchronous, the main thread) * If a thread already has a running async loop, ``AsyncToSync`` can't run things on that loop if it's blocked on synchronous code that is above you in the call stack. The first compromise you get to might be that ``thread_sensitive`` code should just run in the same thread and not spawn in a sub-thread, fulfilling the first restriction, but that immediately runs you into the second restriction. The only real solution is to essentially have a variant of ThreadPoolExecutor that executes any ``thread_sensitive`` code on the outermost synchronous thread - either the main thread, or a single spawned subthread. This means you now have two basic states: * If the outermost layer of your program is synchronous, then all async code run through ``AsyncToSync`` will run in a per-call event loop in arbitrary sub-threads, while all ``thread_sensitive`` code will run in the main thread. * If the outermost layer of your program is asynchronous, then all async code runs on the main thread's event loop, and all ``thread_sensitive`` synchronous code will run in a single shared sub-thread. Crucially, this means that in both cases there is a thread which is a shared resource that all ``thread_sensitive`` code must run on, and there is a chance that this thread is currently blocked on its own ``AsyncToSync`` call. Thus, ``AsyncToSync`` needs to act as an executor for thread code while it's blocking. The ``CurrentThreadExecutor`` class provides this functionality; rather than simply waiting on a Future, you can call its ``run_until_future`` method and it will run submitted code until that Future is done. This means that code inside the call can then run code on your thread. Maintenance and Security ------------------------ To report security issues, please contact security@djangoproject.com. For GPG signatures and more security process information, see https://docs.djangoproject.com/en/dev/internals/security/. To report bugs or request new features, please open a new GitHub issue. This repository is part of the Channels project. For the shepherd and maintenance team, please see the `main Channels readme `_. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1758639645.0 asgiref-3.9.2/asgiref.egg-info/SOURCES.txt0000644000076500000240000000121615064533035017534 0ustar00carltonstaffLICENSE MANIFEST.in README.rst setup.cfg setup.py tox.ini asgiref/__init__.py asgiref/compatibility.py asgiref/current_thread_executor.py asgiref/local.py asgiref/py.typed asgiref/server.py asgiref/sync.py asgiref/testing.py asgiref/timeout.py asgiref/typing.py asgiref/wsgi.py asgiref.egg-info/PKG-INFO asgiref.egg-info/SOURCES.txt asgiref.egg-info/dependency_links.txt asgiref.egg-info/not-zip-safe asgiref.egg-info/requires.txt asgiref.egg-info/top_level.txt tests/test_compatibility.py tests/test_garbage_collection.py tests/test_local.py tests/test_server.py tests/test_sync.py tests/test_sync_contextvars.py tests/test_testing.py tests/test_wsgi.py././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1758639645.0 asgiref-3.9.2/asgiref.egg-info/dependency_links.txt0000644000076500000240000000000115064533035021716 0ustar00carltonstaff ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1728116990.0 asgiref-3.9.2/asgiref.egg-info/not-zip-safe0000644000076500000240000000000114700174376020103 0ustar00carltonstaff ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1758639645.0 asgiref-3.9.2/asgiref.egg-info/requires.txt0000644000076500000240000000013515064533035020247 0ustar00carltonstaff [:python_version < "3.11"] typing_extensions>=4 [tests] pytest pytest-asyncio mypy>=1.14.0 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1758639645.0 asgiref-3.9.2/asgiref.egg-info/top_level.txt0000644000076500000240000000001015064533035020371 0ustar00carltonstaffasgiref ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1758639645.9736114 asgiref-3.9.2/setup.cfg0000644000076500000240000000535315064533036014366 0ustar00carltonstaff[metadata] name = asgiref version = attr: asgiref.__version__ url = https://github.com/django/asgiref/ author = Django Software Foundation author_email = foundation@djangoproject.com description = ASGI specs, helper code, and adapters long_description = file: README.rst license = BSD-3-Clause classifiers = Development Status :: 5 - Production/Stable Environment :: Web Environment Intended Audience :: Developers License :: OSI Approved :: BSD License Operating System :: OS Independent Programming Language :: Python Programming Language :: Python :: 3 Programming Language :: Python :: 3 :: Only Programming Language :: Python :: 3.9 Programming Language :: Python :: 3.10 Programming Language :: Python :: 3.11 Programming Language :: Python :: 3.12 Programming Language :: Python :: 3.13 Topic :: Internet :: WWW/HTTP project_urls = Documentation = https://asgi.readthedocs.io/ Further Documentation = https://docs.djangoproject.com/en/stable/topics/async/#async-adapter-functions Changelog = https://github.com/django/asgiref/blob/master/CHANGELOG.txt [options] python_requires = >=3.9 packages = find: include_package_data = true install_requires = typing_extensions>=4; python_version < "3.11" zip_safe = false [options.extras_require] tests = pytest pytest-asyncio mypy>=1.14.0 [tool:pytest] testpaths = tests asyncio_mode = strict asyncio_default_fixture_loop_scope = function [flake8] exclude = venv/*,tox/*,specs/* ignore = E123,E128,E266,E402,W503,E731,W601,E203 max-line-length = 119 [isort] profile = black multi_line_output = 3 [mypy] warn_unused_ignores = True strict = True [mypy-asgiref.current_thread_executor] disallow_untyped_defs = False check_untyped_defs = False [mypy-asgiref.local] disallow_untyped_defs = False check_untyped_defs = False [mypy-asgiref.sync] disallow_untyped_defs = False check_untyped_defs = False [mypy-asgiref.compatibility] disallow_untyped_defs = False check_untyped_defs = False [mypy-asgiref.wsgi] disallow_untyped_defs = False check_untyped_defs = False [mypy-asgiref.testing] disallow_untyped_defs = False check_untyped_defs = False [mypy-asgiref.server] disallow_untyped_defs = False check_untyped_defs = False [mypy-test_server] disallow_untyped_defs = False check_untyped_defs = False [mypy-test_wsgi] disallow_untyped_defs = False check_untyped_defs = False [mypy-test_testing] disallow_untyped_defs = False check_untyped_defs = False [mypy-test_sync_contextvars] disallow_untyped_defs = False check_untyped_defs = False [mypy-test_sync] disallow_untyped_defs = False check_untyped_defs = False [mypy-test_local] disallow_untyped_defs = False check_untyped_defs = False [mypy-test_compatibility] disallow_untyped_defs = False check_untyped_defs = False [egg_info] tag_build = tag_date = 0 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1711026535.0 asgiref-3.9.2/setup.py0000644000076500000240000000010614577030547014255 0ustar00carltonstafffrom setuptools import setup # type: ignore[import-untyped] setup() ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1758639645.9718397 asgiref-3.9.2/tests/0000755000076500000240000000000015064533036013701 5ustar00carltonstaff././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1650354462.0 asgiref-3.9.2/tests/test_compatibility.py0000644000076500000240000000443114227464436020174 0ustar00carltonstaffimport pytest from asgiref.compatibility import double_to_single_callable, is_double_callable from asgiref.testing import ApplicationCommunicator def double_application_function(scope): """ A nested function based double-callable application. """ async def inner(receive, send): message = await receive() await send({"scope": scope["value"], "message": message["value"]}) return inner class DoubleApplicationClass: """ A classic class-based double-callable application. """ def __init__(self, scope): pass async def __call__(self, receive, send): pass class DoubleApplicationClassNestedFunction: """ A function closure inside a class! """ def __init__(self): pass def __call__(self, scope): async def inner(receive, send): pass return inner async def single_application_function(scope, receive, send): """ A single-function single-callable application """ pass class SingleApplicationClass: """ A single-callable class (where you'd pass the class instance in, e.g. middleware) """ def __init__(self): pass async def __call__(self, scope, receive, send): pass def test_is_double_callable(): """ Tests that the signature matcher works as expected. """ assert is_double_callable(double_application_function) is True assert is_double_callable(DoubleApplicationClass) is True assert is_double_callable(DoubleApplicationClassNestedFunction()) is True assert is_double_callable(single_application_function) is False assert is_double_callable(SingleApplicationClass()) is False def test_double_to_single_signature(): """ Test that the new object passes a signature test. """ assert ( is_double_callable(double_to_single_callable(double_application_function)) is False ) @pytest.mark.asyncio async def test_double_to_single_communicator(): """ Test that the new application works """ new_app = double_to_single_callable(double_application_function) instance = ApplicationCommunicator(new_app, {"value": "woohoo"}) await instance.send_input({"value": 42}) assert await instance.receive_output() == {"scope": "woohoo", "message": 42} ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1751960639.0 asgiref-3.9.2/tests/test_garbage_collection.py0000644000076500000240000000436015033146077021121 0ustar00carltonstaffimport gc import sys import pytest from asgiref.local import Local def disable_gc_for_garbage_collection_test() -> None: # Disable automatic garbage collection. To have control over when # garbage collection is performed. This is necessary to ensure that another # that thread doesn't accidentally trigger it by simply executing code. gc.disable() # Delete the garbage list(`gc.garbage`) to ensure that other tests don't # interfere with this test. gc.collect() # Set the garbage collection debugging flag to store all unreachable # objects in `gc.garbage`. This is necessary to ensure that the # garbage list is empty after execute test code. Otherwise, the test # will always pass. The garbage list isn't automatically populated # because it costs extra CPU cycles gc.set_debug(gc.DEBUG_SAVEALL) def clean_up_after_garbage_collection_test() -> None: # Clean up the garbage collection settings. Re-enable automatic garbage # collection. This step is mandatory to avoid running other tests without # automatic garbage collection. gc.set_debug(0) gc.enable() @pytest.mark.skipif( sys.implementation.name == "pypy", reason="Test relies on CPython GC internals" ) def test_thread_critical_Local_remove_all_reference_cycles() -> None: try: # given # Disable automatic garbage collection and set debugging flag. disable_gc_for_garbage_collection_test() # when # Create thread critical Local object in sync context. try: getattr(Local(thread_critical=True), "missing") except AttributeError: pass # Enforce garbage collection to populate the garbage list for inspection. gc.collect() # then # Ensure that the garbage list is empty. The garbage list is only valid # until the next collection cycle so we can only make assertions about it # before re-enabling automatic collection. assert gc.garbage == [] # Restore garbage collection settings to their original state. This should always be run to avoid interfering # with other tests to ensure that code should be executed in the `finally' block. finally: clean_up_after_garbage_collection_test() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1751965418.0 asgiref-3.9.2/tests/test_local.py0000644000076500000240000002414115033157352016405 0ustar00carltonstaffimport asyncio import gc import threading from threading import Thread import pytest from asgiref.local import Local from asgiref.sync import async_to_sync, sync_to_async @pytest.mark.asyncio async def test_local_task(): """ Tests that local works just inside a normal task context """ test_local = Local() # Unassigned should be an error with pytest.raises(AttributeError): test_local.foo # Assign and check it persists test_local.foo = 1 assert test_local.foo == 1 # Delete and check it errors again del test_local.foo with pytest.raises(AttributeError): test_local.foo def test_local_thread(): """ Tests that local works just inside a normal thread context """ test_local = Local() # Unassigned should be an error with pytest.raises(AttributeError): test_local.foo # Assign and check it persists test_local.foo = 2 assert test_local.foo == 2 # Delete and check it errors again del test_local.foo with pytest.raises(AttributeError): test_local.foo def test_local_thread_nested(): """ Tests that local does not leak across threads """ test_local = Local() # Unassigned should be an error with pytest.raises(AttributeError): test_local.foo # Assign and check it does not persist inside the thread class TestThread(threading.Thread): # Failure reason failed = "unknown" def run(self): # Make sure the attribute is not there try: test_local.foo self.failed = "leak inside" return except AttributeError: pass # Check the value is good self.failed = "set inside" test_local.foo = 123 assert test_local.foo == 123 # Binary signal that these tests passed to the outer thread self.failed = "" test_local.foo = 8 thread = TestThread() thread.start() thread.join() assert thread.failed == "" # Check it didn't leak back out assert test_local.foo == 8 def test_local_cycle(): """ Tests that Local can handle cleanup up a cycle to itself (Borrowed and modified from the CPython threadlocal tests) """ locals = None matched = 0 e1 = threading.Event() e2 = threading.Event() def f(): nonlocal matched # Involve Local in a cycle cycle = [Local()] cycle.append(cycle) cycle[0].foo = "bar" # GC the cycle del cycle gc.collect() # Trigger the local creation outside e1.set() e2.wait() # New Locals should be empty matched = len( [local for local in locals if getattr(local, "foo", None) == "bar"] ) t = threading.Thread(target=f) t.start() e1.wait() # Creates locals outside of the inner thread locals = [Local() for i in range(100)] e2.set() t.join() assert matched == 0 @pytest.mark.asyncio async def test_local_task_to_sync(): """ Tests that local carries through sync_to_async """ # Set up the local test_local = Local() test_local.foo = 3 # Look at it in a sync context def sync_function(): assert test_local.foo == 3 test_local.foo = "phew, done" await sync_to_async(sync_function)() # Check the value passed out again assert test_local.foo == "phew, done" def test_local_thread_to_async(): """ Tests that local carries through async_to_sync """ # Set up the local test_local = Local() test_local.foo = 12 # Look at it in an async context async def async_function(): assert test_local.foo == 12 test_local.foo = "inside" async_to_sync(async_function)() # Check the value passed out again assert test_local.foo == "inside" @pytest.mark.asyncio async def test_local_task_to_sync_to_task(): """ Tests that local carries through sync_to_async and then back through async_to_sync """ # Set up the local test_local = Local() test_local.foo = 756 # Look at it in an async context inside a sync context def sync_function(): async def async_function(): assert test_local.foo == 756 test_local.foo = "dragons" async_to_sync(async_function)() await sync_to_async(sync_function)() # Check the value passed out again assert test_local.foo == "dragons" @pytest.mark.asyncio async def test_local_many_layers(): """ Tests that local carries through a lot of layers of sync/async """ # Set up the local test_local = Local() test_local.foo = 8374 # Make sure we go between each world at least twice def sync_function(): async def async_function(): def sync_function_2(): async def async_function_2(): assert test_local.foo == 8374 test_local.foo = "miracles" async_to_sync(async_function_2)() await sync_to_async(sync_function_2)() async_to_sync(async_function)() await sync_to_async(sync_function)() # Check the value passed out again assert test_local.foo == "miracles" @pytest.mark.asyncio async def test_local_critical_no_task_to_thread(): """ Tests that local doesn't go through sync_to_async when the local is set as thread-critical. """ # Set up the local test_local = Local(thread_critical=True) test_local.foo = 86 # Look at it in a sync context def sync_function(): with pytest.raises(AttributeError): test_local.foo test_local.foo = "secret" assert test_local.foo == "secret" await sync_to_async(sync_function)() # Check the value outside is not touched assert test_local.foo == 86 def test_local_critical_no_thread_to_task(): """ Tests that local does not go through async_to_sync when the local is set as thread-critical """ # Set up the local test_local = Local(thread_critical=True) test_local.foo = 89 # Look at it in an async context async def async_function(): with pytest.raises(AttributeError): test_local.foo test_local.foo = "numbers" assert test_local.foo == "numbers" async_to_sync(async_function)() # Check the value outside assert test_local.foo == 89 @pytest.mark.asyncio async def test_local_threads_and_tasks(): """ Tests that local and threads don't interfere with each other. """ test_local = Local() test_local.counter = 0 def sync_function(expected): assert test_local.counter == expected test_local.counter += 1 async def async_function(expected): assert test_local.counter == expected test_local.counter += 1 await sync_to_async(sync_function)(0) assert test_local.counter == 1 await async_function(1) assert test_local.counter == 2 class TestThread(threading.Thread): def run(self): with pytest.raises(AttributeError): test_local.counter test_local.counter = -1 await sync_to_async(sync_function)(2) assert test_local.counter == 3 threads = [TestThread() for _ in range(5)] for thread in threads: thread.start() threads[0].join() await sync_to_async(sync_function)(3) assert test_local.counter == 4 await async_function(4) assert test_local.counter == 5 for thread in threads[1:]: thread.join() await sync_to_async(sync_function)(5) assert test_local.counter == 6 def test_thread_critical_local_not_context_dependent_in_sync_thread(): # Test function is sync, thread critical local should # be visible everywhere in the sync thread, even if set # from inside a sync_to_async/async_to_sync stack (so # long as it was set in sync code) test_local_tc = Local(thread_critical=True) test_local_not_tc = Local(thread_critical=False) test_thread = threading.current_thread() @sync_to_async def inner_sync_function(): # sync_to_async should run this code inside the original # sync thread, confirm this here assert test_thread == threading.current_thread() test_local_tc.test_value = "_123_" test_local_not_tc.test_value = "_456_" @async_to_sync async def async_function(): await asyncio.create_task(inner_sync_function()) async_function() # assert: the inner_sync_function should have set a value # visible here assert test_local_tc.test_value == "_123_" # however, if the local was non-thread-critical, then the # inner value was set inside a new async context, meaning that # we do not see it, as context vars don't propagate up the stack assert not hasattr(test_local_not_tc, "test_value") def test_visibility_thread_asgiref() -> None: """Check visibility with subthreads.""" test_local = Local() test_local.value = 0 def _test() -> None: # Local() is cleared when changing thread assert not hasattr(test_local, "value") setattr(test_local, "value", 1) assert test_local.value == 1 thread = Thread(target=_test) thread.start() thread.join() assert test_local.value == 0 @pytest.mark.asyncio async def test_visibility_task() -> None: """Check visibility with asyncio tasks.""" test_local = Local() test_local.value = 0 async def _test() -> None: # Local is inherited when changing task assert test_local.value == 0 test_local.value = 1 assert test_local.value == 1 await asyncio.create_task(_test()) # Changes should not leak to the caller assert test_local.value == 0 @pytest.mark.asyncio async def test_deletion() -> None: """Check visibility with asyncio tasks.""" test_local = Local() test_local.value = 123 async def _test() -> None: # Local is inherited when changing task assert test_local.value == 123 del test_local.value assert not hasattr(test_local, "value") await asyncio.create_task(_test()) assert test_local.value == 123 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1751534664.0 asgiref-3.9.2/tests/test_server.py0000644000076500000240000001042615031446110016611 0ustar00carltonstaffimport asyncio import socket as sock import pytest import pytest_asyncio from asgiref.server import StatelessServer async def sock_recvfrom(sock, n): while True: try: return sock.recvfrom(n) except BlockingIOError: await asyncio.sleep(0) class Server(StatelessServer): def __init__(self, application, max_applications=1000): super().__init__( application, max_applications=max_applications, ) self._sock = sock.socket(sock.AF_INET, sock.SOCK_DGRAM) self._sock.setblocking(False) self._sock.bind(("127.0.0.1", 0)) @property def address(self): return self._sock.getsockname() async def handle(self): while True: data, addr = await sock_recvfrom(self._sock, 4096) data = data.decode("utf-8") if data.startswith("Register"): _, usr_name = data.split(" ") input_quene = self.get_or_create_application_instance(usr_name, addr) input_quene.put_nowait(b"Welcome") elif data.startswith("To"): _, usr_name, msg = data.split(" ", 2) input_quene = self.get_or_create_application_instance(usr_name, addr) input_quene.put_nowait(msg.encode("utf-8")) async def application_send(self, scope, message): self._sock.sendto(message, scope) def close(self): self._sock.close() for details in self.application_instances.values(): details["future"].cancel() class Client: def __init__(self, name): self._sock = sock.socket(sock.AF_INET, sock.SOCK_DGRAM) self._sock.setblocking(False) self.name = name async def register(self, server_addr, name=None): name = name or self.name self._sock.sendto(f"Register {name}".encode(), server_addr) async def send(self, server_addr, to, msg): self._sock.sendto(f"To {to} {msg}".encode(), server_addr) async def get_msg(self): msg, server_addr = await sock_recvfrom(self._sock, 4096) return msg, server_addr def close(self): self._sock.close() @pytest_asyncio.fixture(scope="function") async def server(): async def app(scope, receive, send): while True: msg = await receive() await send(msg) server = Server(app, 10) yield server server.close() async def check_client_msg(client, expected_address, expected_msg): msg, server_addr = await asyncio.wait_for(client.get_msg(), timeout=1.0) assert msg == expected_msg assert server_addr == expected_address @pytest.mark.asyncio async def test_stateless_server(server): """StatelessServer can be instantiated with an ASGI 3 application.""" """Create a UDP Server can register instance based on name from message of client. Clients can communicate to other client by name through server""" client1 = Client(name="client1") client2 = Client(name="client2") async def check_client1_behavior(): await client1.register(server.address) await check_client_msg(client1, server.address, b"Welcome") await client1.send(server.address, "client2", "Hello") async def check_client2_behavior(): await client2.register(server.address) await check_client_msg(client2, server.address, b"Welcome") await check_client_msg(client2, server.address, b"Hello") class Done(Exception): pass async def do_test(): await asyncio.gather(check_client1_behavior(), check_client2_behavior()) raise Done try: await asyncio.gather(server.arun(), do_test()) except Done: pass @pytest.mark.asyncio async def test_server_delete_instance(server): """The max_applications of Server is 10. After 20 times register, application number should be 10.""" client1 = Client(name="client1") class Done(Exception): pass async def client1_multiple_register(): for i in range(20): await client1.register(server.address, name=f"client{i}") print(f"client{i}") await check_client_msg(client1, server.address, b"Welcome") raise Done try: await asyncio.gather(client1_multiple_register(), server.arun()) except Done: pass ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1751534724.0 asgiref-3.9.2/tests/test_sync.py0000644000076500000240000010431715031446204016266 0ustar00carltonstaffimport asyncio import functools import multiprocessing import sys import threading import time import warnings from concurrent.futures import ThreadPoolExecutor from functools import wraps from typing import Any from unittest import TestCase import pytest from asgiref.sync import ( ThreadSensitiveContext, async_to_sync, iscoroutinefunction, sync_to_async, ) from asgiref.timeout import timeout @pytest.mark.asyncio async def test_sync_to_async(): """ Tests we can call sync functions from an async thread (even if the number of thread workers is less than the number of calls) """ # Define sync function def sync_function(): time.sleep(1) return 42 # Ensure outermost detection works # Wrap it async_function = sync_to_async(sync_function) # Check it works right start = time.monotonic() result = await async_function() end = time.monotonic() assert result == 42 assert end - start >= 1 # Set workers to 1, call it twice and make sure that works right loop = asyncio.get_running_loop() old_executor = loop._default_executor or ThreadPoolExecutor() loop.set_default_executor(ThreadPoolExecutor(max_workers=1)) try: start = time.monotonic() await asyncio.wait( [ asyncio.create_task(async_function()), asyncio.create_task(async_function()), ] ) end = time.monotonic() # It should take at least 2 seconds as there's only one worker. assert end - start >= 2 finally: loop.set_default_executor(old_executor) def test_sync_to_async_fail_non_function(): """ async_to_sync raises a TypeError when called with a non-function. """ with pytest.raises(TypeError) as excinfo: sync_to_async(1) assert excinfo.value.args == ( "sync_to_async can only be applied to sync functions.", ) @pytest.mark.asyncio async def test_sync_to_async_fail_async(): """ sync_to_async raises a TypeError when applied to a sync function. """ with pytest.raises(TypeError) as excinfo: @sync_to_async async def test_function(): pass assert excinfo.value.args == ( "sync_to_async can only be applied to sync functions.", ) @pytest.mark.asyncio async def test_async_to_sync_fail_partial(): """ sync_to_async raises a TypeError when applied to a sync partial. """ with pytest.raises(TypeError) as excinfo: async def test_function(*args): pass partial_function = functools.partial(test_function, 42) sync_to_async(partial_function) assert excinfo.value.args == ( "sync_to_async can only be applied to sync functions.", ) @pytest.mark.asyncio async def test_sync_to_async_raises_typeerror_for_async_callable_instance(): class CallableClass: async def __call__(self): return None with pytest.raises( TypeError, match="sync_to_async can only be applied to sync functions." ): sync_to_async(CallableClass()) @pytest.mark.asyncio async def test_sync_to_async_decorator(): """ Tests sync_to_async as a decorator """ # Define sync function @sync_to_async def test_function(): time.sleep(1) return 43 # Check it works right result = await test_function() assert result == 43 @pytest.mark.asyncio async def test_nested_sync_to_async_retains_wrapped_function_attributes(): """ Tests that attributes of functions wrapped by sync_to_async are retained """ def enclosing_decorator(attr_value): @wraps(attr_value) def wrapper(f): f.attr_name = attr_value return f return wrapper @enclosing_decorator("test_name_attribute") @sync_to_async def test_function(): pass assert test_function.attr_name == "test_name_attribute" assert test_function.__name__ == "test_function" @pytest.mark.asyncio async def test_sync_to_async_method_decorator(): """ Tests sync_to_async as a method decorator """ # Define sync function class TestClass: @sync_to_async def test_method(self): time.sleep(1) return 44 # Check it works right instance = TestClass() result = await instance.test_method() assert result == 44 @pytest.mark.asyncio async def test_sync_to_async_method_self_attribute(): """ Tests sync_to_async on a method copies __self__ """ # Define sync function class TestClass: def test_method(self): time.sleep(0.1) return 45 # Check it works right instance = TestClass() method = sync_to_async(instance.test_method) result = await method() assert result == 45 # Check __self__ has been copied assert method.__self__ == instance @pytest.mark.asyncio async def test_async_to_sync_to_async(): """ Tests we can call async functions from a sync thread created by async_to_sync (even if the number of thread workers is less than the number of calls) """ result = {} # Define async function async def inner_async_function(): result["worked"] = True result["thread"] = threading.current_thread() return 65 # Define sync function def sync_function(): return async_to_sync(inner_async_function)() # Wrap it async_function = sync_to_async(sync_function) # Check it works right number = await async_function() assert number == 65 assert result["worked"] # Make sure that it didn't needlessly make a new async loop assert result["thread"] == threading.current_thread() @pytest.mark.asyncio async def test_async_to_sync_to_async_decorator(): """ Test async_to_sync as a function decorator uses the outer thread when used inside sync_to_async. """ result = {} # Define async function @async_to_sync async def inner_async_function(): result["worked"] = True result["thread"] = threading.current_thread() return 42 # Define sync function @sync_to_async def sync_function(): return inner_async_function() # Check it works right number = await sync_function() assert number == 42 assert result["worked"] # Make sure that it didn't needlessly make a new async loop assert result["thread"] == threading.current_thread() @pytest.mark.asyncio @pytest.mark.skipif(sys.version_info < (3, 9), reason="requires python3.9") async def test_async_to_sync_to_thread_decorator(): """ Test async_to_sync as a function decorator uses the outer thread when used inside another sync thread. """ result = {} # Define async function @async_to_sync async def inner_async_function(): result["worked"] = True result["thread"] = threading.current_thread() return 42 # Check it works right number = await asyncio.to_thread(inner_async_function) assert number == 42 assert result["worked"] # Make sure that it didn't needlessly make a new async loop assert result["thread"] == threading.current_thread() def test_async_to_sync_fail_non_function(): """ async_to_sync raises a TypeError when applied to a non-function. """ with pytest.warns(UserWarning) as warnings: async_to_sync(1) assert warnings[0].message.args == ( "async_to_sync was passed a non-async-marked callable", ) def test_async_to_sync_fail_sync(): """ async_to_sync raises a TypeError when applied to a sync function. """ with pytest.warns(UserWarning) as warnings: @async_to_sync def test_function(self): pass assert warnings[0].message.args == ( "async_to_sync was passed a non-async-marked callable", ) def test_async_to_sync(): """ Tests we can call async_to_sync outside of an outer event loop. """ result = {} # Define async function async def inner_async_function(): await asyncio.sleep(0) result["worked"] = True return 84 # Run it sync_function = async_to_sync(inner_async_function) number = sync_function() assert number == 84 assert result["worked"] def test_async_to_sync_decorator(): """ Tests we can call async_to_sync as a function decorator """ result = {} # Define async function @async_to_sync async def test_function(): await asyncio.sleep(0) result["worked"] = True return 85 # Run it number = test_function() assert number == 85 assert result["worked"] def test_async_to_sync_method_decorator(): """ Tests we can call async_to_sync as a function decorator """ result = {} # Define async function class TestClass: @async_to_sync async def test_function(self): await asyncio.sleep(0) result["worked"] = True return 86 # Run it instance = TestClass() number = instance.test_function() assert number == 86 assert result["worked"] @pytest.mark.asyncio async def test_async_to_sync_in_async(): """ Makes sure async_to_sync bails if you try to call it from an async loop """ # Define async function async def inner_async_function(): return 84 # Run it sync_function = async_to_sync(inner_async_function) with pytest.raises(RuntimeError): sync_function() def test_async_to_sync_in_thread(): """ Tests we can call async_to_sync inside a thread """ result = {} # Define async function @async_to_sync async def test_function(): await asyncio.sleep(0) result["worked"] = True # Make a thread and run it thread = threading.Thread(target=test_function) thread.start() thread.join() assert result["worked"] def test_async_to_sync_in_except(): """ Tests we can call async_to_sync inside an except block without it re-propagating the exception. """ # Define async function @async_to_sync async def test_function(): return 42 # Run inside except try: raise ValueError("Boom") except ValueError: assert test_function() == 42 def test_async_to_sync_partial(): """ Tests we can call async_to_sync on an async partial. """ result = {} # Define async function async def inner_async_function(*args): await asyncio.sleep(0) result["worked"] = True return [*args] partial_function = functools.partial(inner_async_function, 42) # Run it sync_function = async_to_sync(partial_function) out = sync_function(84) assert out == [42, 84] assert result["worked"] def test_async_to_sync_on_callable_object(): """ Tests async_to_sync on a callable class instance """ result = {} class CallableClass: async def __call__(self, value): await asyncio.sleep(0) result["worked"] = True return value # Run it (without warnings) with warnings.catch_warnings(): warnings.simplefilter("error") sync_function = async_to_sync(CallableClass()) out = sync_function(42) assert out == 42 assert result["worked"] is True def test_async_to_sync_method_self_attribute(): """ Tests async_to_sync on a method copies __self__. """ # Define async function. class TestClass: async def test_function(self): await asyncio.sleep(0) return 45 # Check it works right. instance = TestClass() sync_function = async_to_sync(instance.test_function) number = sync_function() assert number == 45 # Check __self__ has been copied. assert sync_function.__self__ is instance def test_thread_sensitive_outside_sync(): """ Tests that thread_sensitive SyncToAsync where the outside is sync code runs in the main thread. """ result = {} # Middle async function @async_to_sync async def middle(): await inner() await asyncio.create_task(inner_task()) # Inner sync functions @sync_to_async def inner(): result["thread"] = threading.current_thread() @sync_to_async def inner_task(): result["thread2"] = threading.current_thread() # Run it middle() assert result["thread"] == threading.current_thread() assert result["thread2"] == threading.current_thread() @pytest.mark.asyncio async def test_thread_sensitive_outside_async(): """ Tests that thread_sensitive SyncToAsync where the outside is async code runs in a single, separate thread. """ result_1 = {} result_2 = {} # Outer sync function @sync_to_async def outer(result): middle(result) # Middle async function @async_to_sync async def middle(result): await inner(result) # Inner sync function @sync_to_async def inner(result): result["thread"] = threading.current_thread() # Run it (in supposed parallel!) await asyncio.wait( [asyncio.create_task(outer(result_1)), asyncio.create_task(inner(result_2))] ) # They should not have run in the main thread, but in the same thread assert result_1["thread"] != threading.current_thread() assert result_1["thread"] == result_2["thread"] @pytest.mark.asyncio async def test_thread_sensitive_with_context_matches(): result_1 = {} result_2 = {} def store_thread(result): result["thread"] = threading.current_thread() store_thread_async = sync_to_async(store_thread) async def fn(): async with ThreadSensitiveContext(): # Run it (in supposed parallel!) await asyncio.wait( [ asyncio.create_task(store_thread_async(result_1)), asyncio.create_task(store_thread_async(result_2)), ] ) await fn() # They should not have run in the main thread, and on the same threads assert result_1["thread"] != threading.current_thread() assert result_1["thread"] == result_2["thread"] @pytest.mark.asyncio async def test_thread_sensitive_nested_context(): result_1 = {} result_2 = {} @sync_to_async def store_thread(result): result["thread"] = threading.current_thread() async with ThreadSensitiveContext(): await store_thread(result_1) async with ThreadSensitiveContext(): await store_thread(result_2) # They should not have run in the main thread, and on the same threads assert result_1["thread"] != threading.current_thread() assert result_1["thread"] == result_2["thread"] @pytest.mark.asyncio async def test_thread_sensitive_context_without_sync_work(): async with ThreadSensitiveContext(): pass def test_thread_sensitive_double_nested_sync(): """ Tests that thread_sensitive SyncToAsync nests inside itself where the outside is sync. """ result = {} # Async level 1 @async_to_sync async def level1(): await level2() # Sync level 2 @sync_to_async def level2(): level3() # Async level 3 @async_to_sync async def level3(): await level4() # Sync level 2 @sync_to_async def level4(): result["thread"] = threading.current_thread() # Run it level1() assert result["thread"] == threading.current_thread() @pytest.mark.asyncio async def test_thread_sensitive_double_nested_async(): """ Tests that thread_sensitive SyncToAsync nests inside itself where the outside is async. """ result = {} # Sync level 1 @sync_to_async def level1(): level2() # Async level 2 @async_to_sync async def level2(): await level3() # Sync level 3 @sync_to_async def level3(): level4() # Async level 4 @async_to_sync async def level4(): result["thread"] = threading.current_thread() # Run it await level1() assert result["thread"] == threading.current_thread() def test_thread_sensitive_disabled(): """ Tests that we can disable thread sensitivity and make things run in separate threads. """ result = {} # Middle async function @async_to_sync async def middle(): await inner() # Inner sync function @sync_to_async(thread_sensitive=False) def inner(): result["thread"] = threading.current_thread() # Run it middle() assert result["thread"] != threading.current_thread() class ASGITest(TestCase): """ Tests collection of async cases inside classes """ @async_to_sync async def test_wrapped_case_is_collected(self): self.assertTrue(True) def test_sync_to_async_detected_as_coroutinefunction(): """ Tests that SyncToAsync functions are detected as coroutines. """ def sync_func(): return assert not iscoroutinefunction(sync_to_async) assert iscoroutinefunction(sync_to_async(sync_func)) async def async_process(queue): queue.put(42) def sync_process(queue): """Runs async_process synchronously""" async_to_sync(async_process)(queue) def fork_first(): """Forks process before running sync_process""" queue = multiprocessing.Queue() fork = multiprocessing.Process(target=sync_process, args=[queue]) fork.start() fork.join(3) # Force cleanup in failed test case if fork.is_alive(): fork.terminate() return queue.get(True, 1) @pytest.mark.asyncio async def test_multiprocessing(): """ Tests that a forked process can use async_to_sync without it looking for the event loop from the parent process. """ assert await sync_to_async(fork_first)() == 42 @pytest.mark.asyncio async def test_sync_to_async_uses_executor(): """ Tests that SyncToAsync uses the passed in executor correctly. """ class CustomExecutor: def __init__(self): self.executor = ThreadPoolExecutor(max_workers=1) self.times_submit_called = 0 def submit(self, callable_, *args, **kwargs): self.times_submit_called += 1 return self.executor.submit(callable_, *args, **kwargs) expected_result = "expected_result" def sync_func(): return expected_result custom_executor = CustomExecutor() async_function = sync_to_async( sync_func, thread_sensitive=False, executor=custom_executor ) actual_result = await async_function() assert actual_result == expected_result assert custom_executor.times_submit_called == 1 pytest.raises( TypeError, sync_to_async, sync_func, thread_sensitive=True, executor=custom_executor, ) def test_sync_to_async_deadlock_ignored_with_exception(): """ Ensures that throwing an exception from inside a deadlock-protected block still resets the deadlock detector's status. """ def view(): raise ValueError() async def server_entry(): try: await sync_to_async(view)() except ValueError: pass try: await sync_to_async(view)() except ValueError: pass asyncio.run(server_entry()) @pytest.mark.asyncio @pytest.mark.xfail async def test_sync_to_async_with_blocker_thread_sensitive(): """ Tests sync_to_async running on a long-time blocker in a thread_sensitive context. Expected to fail at the moment. """ delay = 1 # second event = multiprocessing.Event() async def async_process_waiting_on_event(): """Wait for the event to be set.""" await sync_to_async(event.wait)() return 42 async def async_process_that_triggers_event(): """Sleep, then set the event.""" await asyncio.sleep(delay) await sync_to_async(event.set)() # Run the event setter as a task. trigger_task = asyncio.ensure_future(async_process_that_triggers_event()) try: # wait on the event waiter, which is now blocking the event setter. async with timeout(delay + 1): assert await async_process_waiting_on_event() == 42 except asyncio.TimeoutError: # In case of timeout, set the event to unblock things, else # downstream tests will get fouled up. event.set() raise finally: await trigger_task @pytest.mark.asyncio async def test_sync_to_async_with_blocker_non_thread_sensitive(): """ Tests sync_to_async running on a long-time blocker in a non_thread_sensitive context. """ delay = 1 # second event = multiprocessing.Event() async def async_process_waiting_on_event(): """Wait for the event to be set.""" await sync_to_async(event.wait, thread_sensitive=False)() return 42 async def async_process_that_triggers_event(): """Sleep, then set the event.""" await asyncio.sleep(1) await sync_to_async(event.set)() # Run the event setter as a task. trigger_task = asyncio.ensure_future(async_process_that_triggers_event()) try: # wait on the event waiter, which is now blocking the event setter. async with timeout(delay + 1): assert await async_process_waiting_on_event() == 42 except asyncio.TimeoutError: # In case of timeout, set the event to unblock things, else # downstream tests will get fouled up. event.set() raise finally: await trigger_task @pytest.mark.asyncio async def test_sync_to_async_within_create_task(): """ Test a stack of sync_to_async/async_to_sync/sync_to_async works even when last sync_to_async is wrapped in asyncio.wait_for. """ main_thread = threading.current_thread() sync_thread = None # Hypothetical Django scenario - middleware function is sync and will run # in a new thread created by sync_to_async def sync_middleware(): nonlocal sync_thread sync_thread = threading.current_thread() assert sync_thread != main_thread # View is async and wrapped with async_to_sync. async_to_sync(async_view)() async def async_view(): # Call a sync function using sync_to_async, but asyncio.wait_for it # rather than directly await it. await asyncio.wait_for(sync_to_async(sync_task)(), timeout=1) task_executed = False def sync_task(): nonlocal task_executed, sync_thread assert sync_thread == threading.current_thread() task_executed = True async with ThreadSensitiveContext(): await sync_to_async(sync_middleware)() assert task_executed @pytest.mark.asyncio async def test_inner_shield_sync_middleware(): """ Tests that asyncio.shield is capable of preventing http.disconnect from cancelling a django request task when using sync middleware. """ # Hypothetical Django scenario - middleware function is sync def sync_middleware(): async_to_sync(async_view)() task_complete = False task_cancel_caught = False # Future that completes when subtask cancellation attempt is caught task_blocker = asyncio.Future() async def async_view(): """Async view with a task that is shielded from cancellation.""" nonlocal task_complete, task_cancel_caught, task_blocker task = asyncio.create_task(async_task()) try: await asyncio.shield(task) except asyncio.CancelledError: task_cancel_caught = True task_blocker.set_result(True) await task task_complete = True task_executed = False # Future that completes after subtask is created task_started_future = asyncio.Future() async def async_task(): """Async subtask that should not be canceled when parent is canceled.""" nonlocal task_started_future, task_executed, task_blocker task_started_future.set_result(True) await task_blocker task_executed = True task_cancel_propagated = False async with ThreadSensitiveContext(): task = asyncio.create_task(sync_to_async(sync_middleware)()) await task_started_future task.cancel() try: await task except asyncio.CancelledError: task_cancel_propagated = True assert not task_cancel_propagated assert task_cancel_caught assert task_complete assert task_executed @pytest.mark.asyncio async def test_inner_shield_async_middleware(): """ Tests that asyncio.shield is capable of preventing http.disconnect from cancelling a django request task when using async middleware. """ # Hypothetical Django scenario - middleware function is async async def async_middleware(): await async_view() task_complete = False task_cancel_caught = False # Future that completes when subtask cancellation attempt is caught task_blocker = asyncio.Future() async def async_view(): """Async view with a task that is shielded from cancellation.""" nonlocal task_complete, task_cancel_caught, task_blocker task = asyncio.create_task(async_task()) try: await asyncio.shield(task) except asyncio.CancelledError: task_cancel_caught = True task_blocker.set_result(True) await task task_complete = True task_executed = False # Future that completes after subtask is created task_started_future = asyncio.Future() async def async_task(): """Async subtask that should not be canceled when parent is canceled.""" nonlocal task_started_future, task_executed, task_blocker task_started_future.set_result(True) await task_blocker task_executed = True task_cancel_propagated = False async with ThreadSensitiveContext(): task = asyncio.create_task(async_middleware()) await task_started_future task.cancel() try: await task except asyncio.CancelledError: task_cancel_propagated = True assert not task_cancel_propagated assert task_cancel_caught assert task_complete assert task_executed @pytest.mark.asyncio async def test_inner_shield_sync_and_async_middleware(): """ Tests that asyncio.shield is capable of preventing http.disconnect from cancelling a django request task when using sync and middleware chained together. """ # Hypothetical Django scenario - middleware function is sync def sync_middleware_1(): async_to_sync(async_middleware_2)() # Hypothetical Django scenario - middleware function is async async def async_middleware_2(): await sync_to_async(sync_middleware_3)() # Hypothetical Django scenario - middleware function is sync def sync_middleware_3(): async_to_sync(async_middleware_4)() # Hypothetical Django scenario - middleware function is async async def async_middleware_4(): await sync_to_async(sync_middleware_5)() # Hypothetical Django scenario - middleware function is sync def sync_middleware_5(): async_to_sync(async_view)() task_complete = False task_cancel_caught = False # Future that completes when subtask cancellation attempt is caught task_blocker = asyncio.Future() async def async_view(): """Async view with a task that is shielded from cancellation.""" nonlocal task_complete, task_cancel_caught, task_blocker task = asyncio.create_task(async_task()) try: await asyncio.shield(task) except asyncio.CancelledError: task_cancel_caught = True task_blocker.set_result(True) await task task_complete = True task_executed = False # Future that completes after subtask is created task_started_future = asyncio.Future() async def async_task(): """Async subtask that should not be canceled when parent is canceled.""" nonlocal task_started_future, task_executed, task_blocker task_started_future.set_result(True) await task_blocker task_executed = True task_cancel_propagated = False async with ThreadSensitiveContext(): task = asyncio.create_task(sync_to_async(sync_middleware_1)()) await task_started_future task.cancel() try: await task except asyncio.CancelledError: task_cancel_propagated = True assert not task_cancel_propagated assert task_cancel_caught assert task_complete assert task_executed @pytest.mark.asyncio async def test_inner_shield_sync_and_async_middleware_sync_task(): """ Tests that asyncio.shield is capable of preventing http.disconnect from cancelling a django request task when using sync and middleware chained together with an async view calling a sync function calling an async task. This test ensures that a parent initiated task cancellation will not propagate to a shielded subtask. """ # Hypothetical Django scenario - middleware function is sync def sync_middleware_1(): async_to_sync(async_middleware_2)() # Hypothetical Django scenario - middleware function is async async def async_middleware_2(): await sync_to_async(sync_middleware_3)() # Hypothetical Django scenario - middleware function is sync def sync_middleware_3(): async_to_sync(async_middleware_4)() # Hypothetical Django scenario - middleware function is async async def async_middleware_4(): await sync_to_async(sync_middleware_5)() # Hypothetical Django scenario - middleware function is sync def sync_middleware_5(): async_to_sync(async_view)() task_complete = False task_cancel_caught = False # Future that completes when subtask cancellation attempt is caught task_blocker = asyncio.Future() async def async_view(): """Async view with a task that is shielded from cancellation.""" nonlocal task_complete, task_cancel_caught, task_blocker task = asyncio.create_task(sync_to_async(sync_parent)()) try: await asyncio.shield(task) except asyncio.CancelledError: task_cancel_caught = True task_blocker.set_result(True) await task task_complete = True task_executed = False # Future that completes after subtask is created task_started_future = asyncio.Future() def sync_parent(): async_to_sync(async_task)() async def async_task(): """Async subtask that should not be canceled when parent is canceled.""" nonlocal task_started_future, task_executed, task_blocker task_started_future.set_result(True) await task_blocker task_executed = True task_cancel_propagated = False async with ThreadSensitiveContext(): task = asyncio.create_task(sync_to_async(sync_middleware_1)()) await task_started_future task.cancel() try: await task except asyncio.CancelledError: task_cancel_propagated = True assert not task_cancel_propagated assert task_cancel_caught assert task_complete assert task_executed def test_async_to_sync_overlapping_kwargs() -> None: """ Tests that AsyncToSync correctly passes through kwargs to the wrapped function, particularly in the case where the wrapped function uses same names for the parameters as the wrapper. """ @async_to_sync async def test_function(**kwargs: Any) -> None: assert kwargs # AsyncToSync.main_wrap has a param named `context`. # So we pass the same argument here to test for the error # "AsyncToSync.main_wrap() got multiple values for argument ''" test_function(context=1) @pytest.mark.asyncio async def test_sync_to_async_overlapping_kwargs() -> None: """ Tests that SyncToAsync correctly passes through kwargs to the wrapped function, particularly in the case where the wrapped function uses same names for the parameters as the wrapper. """ @sync_to_async def test_function(**kwargs: Any) -> None: assert kwargs # SyncToAsync.__call__.loop.run_in_executor has a param named `task_context`. await test_function(task_context=1) def test_nested_task() -> None: async def inner() -> asyncio.Task[None]: return asyncio.create_task(sync_to_async(print)("inner")) async def main() -> None: task = await sync_to_async(async_to_sync(inner))() await task async_to_sync(main)() def test_nested_task_later() -> None: def later(fut: asyncio.Future[asyncio.Task[None]]) -> None: task = asyncio.create_task(sync_to_async(print)("later")) fut.set_result(task) async def inner() -> asyncio.Future[asyncio.Task[None]]: loop = asyncio.get_running_loop() fut = loop.create_future() loop.call_later(0.1, later, fut) return fut async def main() -> None: fut = await sync_to_async(async_to_sync(inner))() task = await fut await task async_to_sync(main)() def test_double_nested_task() -> None: async def inner() -> asyncio.Task[None]: return asyncio.create_task(sync_to_async(print)("inner")) async def outer() -> asyncio.Task[asyncio.Task[None]]: return asyncio.create_task(sync_to_async(async_to_sync(inner))()) async def main() -> None: outer_task = await sync_to_async(async_to_sync(outer))() inner_task = await outer_task await inner_task async_to_sync(main)() # asyncio.Barrier is new in Python 3.11. Nest definition (rather than using # skipIf) to avoid mypy error. if sys.version_info >= (3, 11): def test_two_nested_tasks_with_asyncio_run() -> None: barrier = asyncio.Barrier(3) event = threading.Event() async def inner() -> None: task = asyncio.create_task(sync_to_async(event.wait)()) await barrier.wait() await task async def outer() -> tuple[asyncio.Task[None], asyncio.Task[None]]: task0 = asyncio.create_task(inner()) task1 = asyncio.create_task(inner()) await barrier.wait() event.set() return task0, task1 async def main() -> None: task0, task1 = await sync_to_async(async_to_sync(outer))() await task0 await task1 asyncio.run(main()) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1710425211.0 asgiref-3.9.2/tests/test_sync_contextvars.py0000644000076500000240000000411114574602173020727 0ustar00carltonstaffimport asyncio import contextvars import threading import time import pytest from asgiref.sync import ThreadSensitiveContext, async_to_sync, sync_to_async foo: "contextvars.ContextVar[str]" = contextvars.ContextVar("foo") @pytest.mark.asyncio async def test_thread_sensitive_with_context_different(): result_1 = {} result_2 = {} @sync_to_async def store_thread(result): result["thread"] = threading.current_thread() async def fn(result): async with ThreadSensitiveContext(): await store_thread(result) # Run it (in true parallel!) await asyncio.wait( [asyncio.create_task(fn(result_1)), asyncio.create_task(fn(result_2))] ) # They should not have run in the main thread, and on different threads assert result_1["thread"] != threading.current_thread() assert result_1["thread"] != result_2["thread"] @pytest.mark.asyncio async def test_sync_to_async_contextvars(): """ Tests to make sure that contextvars from the calling context are present in the called context, and that any changes in the called context are then propagated back to the calling context. """ # Define sync function def sync_function(): time.sleep(1) assert foo.get() == "bar" foo.set("baz") return 42 # Ensure outermost detection works # Wrap it foo.set("bar") async_function = sync_to_async(sync_function) assert await async_function() == 42 assert foo.get() == "baz" def test_async_to_sync_contextvars(): """ Tests to make sure that contextvars from the calling context are present in the called context, and that any changes in the called context are then propagated back to the calling context. """ # Define sync function async def async_function(): await asyncio.sleep(1) assert foo.get() == "bar" foo.set("baz") return 42 # Ensure outermost detection works # Wrap it foo.set("bar") sync_function = async_to_sync(async_function) assert sync_function() == 42 assert foo.get() == "baz" ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1751534664.0 asgiref-3.9.2/tests/test_testing.py0000644000076500000240000000535315031446110016763 0ustar00carltonstaffimport asyncio import pytest from asgiref.testing import ApplicationCommunicator from asgiref.wsgi import WsgiToAsgi @pytest.mark.asyncio async def test_receive_nothing(): """ Tests ApplicationCommunicator.receive_nothing to return the correct value. """ # Get an ApplicationCommunicator instance def wsgi_application(environ, start_response): start_response("200 OK", []) yield b"content" application = WsgiToAsgi(wsgi_application) instance = ApplicationCommunicator( application, { "type": "http", "http_version": "1.0", "method": "GET", "path": "/foo/", "query_string": b"bar=baz", "headers": [], }, ) # No event assert await instance.receive_nothing() is True # Produce 3 events to receive await instance.send_input({"type": "http.request"}) # Start event of the response assert await instance.receive_nothing() is False await instance.receive_output() # First body event of the response announcing further body event assert await instance.receive_nothing() is False await instance.receive_output() # Last body event of the response assert await instance.receive_nothing() is False await instance.receive_output() # Response received completely assert await instance.receive_nothing(0.01) is True def test_receive_nothing_lazy_loop(): """ Tests ApplicationCommunicator.receive_nothing to return the correct value. """ # Get an ApplicationCommunicator instance def wsgi_application(environ, start_response): start_response("200 OK", []) yield b"content" application = WsgiToAsgi(wsgi_application) instance = ApplicationCommunicator( application, { "type": "http", "http_version": "1.0", "method": "GET", "path": "/foo/", "query_string": b"bar=baz", "headers": [], }, ) async def test(): # No event assert await instance.receive_nothing() is True # Produce 3 events to receive await instance.send_input({"type": "http.request"}) # Start event of the response assert await instance.receive_nothing() is False await instance.receive_output() # First body event of the response announcing further body event assert await instance.receive_nothing() is False await instance.receive_output() # Last body event of the response assert await instance.receive_nothing() is False await instance.receive_output() # Response received completely assert await instance.receive_nothing(0.01) is True asyncio.run(test()) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1733559318.0 asgiref-3.9.2/tests/test_wsgi.py0000644000076500000240000002211214725002026016252 0ustar00carltonstaffimport sys import pytest from asgiref.testing import ApplicationCommunicator from asgiref.wsgi import WsgiToAsgi, WsgiToAsgiInstance @pytest.mark.asyncio async def test_basic_wsgi(): """ Makes sure the WSGI wrapper has basic functionality. """ # Define WSGI app def wsgi_application(environ, start_response): assert environ["HTTP_TEST_HEADER"] == "test value 1,test value 2" start_response("200 OK", [["X-Colour", "Blue"]]) yield b"first chunk " yield b"second chunk" # Wrap it application = WsgiToAsgi(wsgi_application) # Launch it as a test application instance = ApplicationCommunicator( application, { "type": "http", "http_version": "1.0", "method": "GET", "path": "/foo/", "query_string": b"bar=baz", "headers": [ [b"test-header", b"test value 1"], [b"test-header", b"test value 2"], ], }, ) await instance.send_input({"type": "http.request"}) # Check they send stuff assert (await instance.receive_output(1)) == { "type": "http.response.start", "status": 200, "headers": [(b"x-colour", b"Blue")], } assert (await instance.receive_output(1)) == { "type": "http.response.body", "body": b"first chunk ", "more_body": True, } assert (await instance.receive_output(1)) == { "type": "http.response.body", "body": b"second chunk", "more_body": True, } assert (await instance.receive_output(1)) == {"type": "http.response.body"} def test_script_name(): scope = { "type": "http", "http_version": "1.0", "method": "GET", "root_path": "/base", "path": "/base/foo/", "query_string": b"bar=baz", "headers": [ [b"test-header", b"test value 1"], [b"test-header", b"test value 2"], ], } adapter = WsgiToAsgiInstance(None) adapter.scope = scope environ = adapter.build_environ(scope, None) assert environ["SCRIPT_NAME"] == "/base" assert environ["PATH_INFO"] == "/foo/" @pytest.mark.asyncio async def test_wsgi_path_encoding(): """ Makes sure the WSGI wrapper has basic functionality. """ # Define WSGI app def wsgi_application(environ, start_response): assert environ["SCRIPT_NAME"] == "/中国".encode().decode("latin-1") assert environ["PATH_INFO"] == "/中文".encode().decode("latin-1") start_response("200 OK", []) yield b"" # Wrap it application = WsgiToAsgi(wsgi_application) # Launch it as a test application instance = ApplicationCommunicator( application, { "type": "http", "http_version": "1.0", "method": "GET", "path": "/中文", "root_path": "/中国", "query_string": b"bar=baz", "headers": [], }, ) await instance.send_input({"type": "http.request"}) # Check they send stuff assert (await instance.receive_output(1)) == { "type": "http.response.start", "status": 200, "headers": [], } assert (await instance.receive_output(1)) == { "type": "http.response.body", "body": b"", "more_body": True, } assert (await instance.receive_output(1)) == {"type": "http.response.body"} @pytest.mark.asyncio async def test_wsgi_empty_body(): """ Makes sure WsgiToAsgi handles an empty body response correctly """ def wsgi_application(environ, start_response): start_response("200 OK", []) return [] application = WsgiToAsgi(wsgi_application) instance = ApplicationCommunicator( application, { "type": "http", "http_version": "1.0", "method": "GET", "path": "/", "query_string": b"", "headers": [], }, ) await instance.send_input({"type": "http.request"}) # response.start should always be send assert (await instance.receive_output(1)) == { "type": "http.response.start", "status": 200, "headers": [], } assert (await instance.receive_output(1)) == {"type": "http.response.body"} @pytest.mark.asyncio async def test_wsgi_clamped_body(): """ Makes sure WsgiToAsgi clamps a body response longer than Content-Length """ def wsgi_application(environ, start_response): start_response("200 OK", [("Content-Length", "8")]) return [b"0123", b"45", b"6789"] application = WsgiToAsgi(wsgi_application) instance = ApplicationCommunicator( application, { "type": "http", "http_version": "1.0", "method": "GET", "path": "/", "query_string": b"", "headers": [], }, ) await instance.send_input({"type": "http.request"}) assert (await instance.receive_output(1)) == { "type": "http.response.start", "status": 200, "headers": [(b"content-length", b"8")], } assert (await instance.receive_output(1)) == { "type": "http.response.body", "body": b"0123", "more_body": True, } assert (await instance.receive_output(1)) == { "type": "http.response.body", "body": b"45", "more_body": True, } assert (await instance.receive_output(1)) == { "type": "http.response.body", "body": b"67", "more_body": True, } assert (await instance.receive_output(1)) == {"type": "http.response.body"} @pytest.mark.asyncio async def test_wsgi_stops_iterating_after_content_length_bytes(): """ Makes sure WsgiToAsgi does not iterate after than Content-Length bytes """ def wsgi_application(environ, start_response): start_response("200 OK", [("Content-Length", "4")]) yield b"0123" pytest.fail("WsgiToAsgi should not iterate after Content-Length bytes") yield b"4567" application = WsgiToAsgi(wsgi_application) instance = ApplicationCommunicator( application, { "type": "http", "http_version": "1.0", "method": "GET", "path": "/", "query_string": b"", "headers": [], }, ) await instance.send_input({"type": "http.request"}) assert (await instance.receive_output(1)) == { "type": "http.response.start", "status": 200, "headers": [(b"content-length", b"4")], } assert (await instance.receive_output(1)) == { "type": "http.response.body", "body": b"0123", "more_body": True, } assert (await instance.receive_output(1)) == {"type": "http.response.body"} @pytest.mark.asyncio async def test_wsgi_multiple_start_response(): """ Makes sure WsgiToAsgi only keep Content-Length from the last call to start_response """ def wsgi_application(environ, start_response): start_response("200 OK", [("Content-Length", "5")]) try: raise ValueError("Application Error") except ValueError: start_response("500 Server Error", [], sys.exc_info()) return [b"Some long error message"] application = WsgiToAsgi(wsgi_application) instance = ApplicationCommunicator( application, { "type": "http", "http_version": "1.0", "method": "GET", "path": "/", "query_string": b"", "headers": [], }, ) await instance.send_input({"type": "http.request"}) assert (await instance.receive_output(1)) == { "type": "http.response.start", "status": 500, "headers": [], } assert (await instance.receive_output(1)) == { "type": "http.response.body", "body": b"Some long error message", "more_body": True, } assert (await instance.receive_output(1)) == {"type": "http.response.body"} @pytest.mark.asyncio async def test_wsgi_multi_body(): """ Verify that multiple http.request events with body parts are all delivered to the WSGI application. """ def wsgi_application(environ, start_response): infp = environ["wsgi.input"] body = infp.read(12) assert body == b"Hello World!" start_response("200 OK", []) return [] application = WsgiToAsgi(wsgi_application) instance = ApplicationCommunicator( application, { "type": "http", "http_version": "1.0", "method": "POST", "path": "/", "query_string": b"", "headers": [[b"content-length", b"12"]], }, ) await instance.send_input( {"type": "http.request", "body": b"Hello ", "more_body": True} ) await instance.send_input({"type": "http.request", "body": b"World!"}) assert (await instance.receive_output(1)) == { "type": "http.response.start", "status": 200, "headers": [], } assert (await instance.receive_output(1)) == {"type": "http.response.body"} ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1758638678.0 asgiref-3.9.2/tox.ini0000644000076500000240000000051315064531126014047 0ustar00carltonstaff[tox] envlist = py{39,310,311,312,313,314}-{test,mypy} qa [testenv] usedevelop = true extras = tests commands = test: pytest -v {posargs} mypy: mypy . {posargs} deps = setuptools [testenv:qa] skip_install = true deps = pre-commit commands = pre-commit {posargs:run --all-files --show-diff-on-failure}