asgiref 3.8.1__tar.gz → 3.9.0__tar.gz

{asgiref-3.8.1/asgiref.egg-info → asgiref-3.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: asgiref
-Version: 3.8.1
+Version: 3.9.0
 Summary: ASGI specs, helper code, and adapters
 Home-page: https://github.com/django/asgiref/
 Author: Django Software Foundation
@@ -17,19 +17,20 @@ 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.8
 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.8
+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>=0.800; extra == "tests"
+Requires-Dist: mypy>=1.14.0; extra == "tests"
+Dynamic: license-file
 
 asgiref
 =======
@@ -129,7 +130,7 @@ file handles for incoming POST bodies).
 Dependencies
 ------------
 
-``asgiref`` requires Python 3.8 or higher.
+``asgiref`` requires Python 3.9 or higher.
 
 
 Contributing
@@ -179,7 +180,7 @@ Then, build and push the packages::
 
     python -m build
     twine upload dist/*
-    rm -r build/ dist/
+    rm -r asgiref.egg-info dist
 
 
 Implementation Details

{asgiref-3.8.1 → asgiref-3.9.0}/README.rst

@@ -96,7 +96,7 @@ file handles for incoming POST bodies).
 Dependencies
 ------------
 
-``asgiref`` requires Python 3.8 or higher.
+``asgiref`` requires Python 3.9 or higher.
 
 
 Contributing
@@ -146,7 +146,7 @@ Then, build and push the packages::
 
     python -m build
     twine upload dist/*
-    rm -r build/ dist/
+    rm -r asgiref.egg-info dist
 
 
 Implementation Details

asgiref-3.9.0/asgiref/__init__.py

@@ -0,0 +1 @@
+__version__ = "3.9.0"

{asgiref-3.8.1 → asgiref-3.9.0}/asgiref/current_thread_executor.py

@@ -1,8 +1,8 @@
-import queue
 import sys
 import threading
+from collections import deque
 from concurrent.futures import Executor, Future
-from typing import TYPE_CHECKING, Any, Callable, TypeVar, Union
+from typing import Any, Callable, TypeVar
 
 if sys.version_info >= (3, 10):
     from typing import ParamSpec
@@ -53,10 +53,12 @@ class CurrentThreadExecutor(Executor):
     the thread they came from.
     """
 
-    def __init__(self) -> None:
+    def __init__(self, old_executor: "CurrentThreadExecutor | None") -> None:
         self._work_thread = threading.current_thread()
-        self._work_queue: queue.Queue[Union[_WorkItem, "Future[Any]"]] = queue.Queue()
-        self._broken = False
+        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:
         """
@@ -68,24 +70,30 @@ class CurrentThreadExecutor(Executor):
             raise RuntimeError(
                 "You cannot run CurrentThreadExecutor from a different thread"
             )
-        future.add_done_callback(self._work_queue.put)
-        # Keep getting and running work items until we get the future we're waiting for
-        # back via the future's done callback.
-        try:
-            while True:
+
+        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_queue.get()
-                if work_item is future:
-                    return
-                assert isinstance(work_item, _WorkItem)
-                work_item.run()
-                del work_item
-        finally:
-            self._broken = True
+                work_item = self._work_items.popleft()
+            work_item.run()
+            del work_item
 
-    def _submit(
+    def submit(
         self,
         fn: Callable[_P, _R],
+        /,
         *args: _P.args,
         **kwargs: _P.kwargs,
     ) -> "Future[_R]":
@@ -94,22 +102,22 @@ class CurrentThreadExecutor(Executor):
             raise RuntimeError(
                 "You cannot submit onto CurrentThreadExecutor from its own thread"
             )
-        # Check they're not too late or the executor errored
-        if self._broken:
-            raise RuntimeError("CurrentThreadExecutor already quit or is broken")
-        # Add to work queue
         f: "Future[_R]" = Future()
         work_item = _WorkItem(f, fn, *args, **kwargs)
-        self._work_queue.put(work_item)
-        # Return the future
-        return f
 
-    # Python 3.9+ has a new signature for submit with a "/" after `fn`, to enforce
-    # it to be a positional argument. If we ignore[override] mypy on 3.9+ will be
-    # happy but 3.8 will say that the ignore comment is unused, even when
-    # defining them differently based on sys.version_info.
-    # We should be able to remove this when we drop support for 3.8.
-    if not TYPE_CHECKING:
+        # 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
 
-        def submit(self, fn, *args, **kwargs):
-            return self._submit(fn, *args, **kwargs)
+        # Return the future
+        return f

{asgiref-3.8.1 → asgiref-3.9.0}/asgiref/local.py

@@ -2,37 +2,38 @@ import asyncio
 import contextlib
 import contextvars
 import threading
-from typing import Any, Dict, Union
+from typing import Any, Union
 
 
 class _CVar:
     """Storage utility for Local."""
 
     def __init__(self) -> None:
-        self._data: "contextvars.ContextVar[Dict[str, Any]]" = contextvars.ContextVar(
-            "asgiref.local"
-        )
+        self._data: dict[str, contextvars.ContextVar[Any]] = {}
 
-    def __getattr__(self, key):
-        storage_object = self._data.get({})
+    def __getattr__(self, key: str) -> Any:
         try:
-            return storage_object[key]
+            var = self._data[key]
         except KeyError:
             raise AttributeError(f"{self!r} object has no attribute {key!r}")
 
+        try:
+            return var.get()
+        except LookupError:
+            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({})
-        storage_object[key] = value
-        self._data.set(storage_object)
+        var = self._data.get(key)
+        if var is None:
+            self._data[key] = var = contextvars.ContextVar(key)
+        var.set(value)
 
     def __delattr__(self, key: str) -> None:
-        storage_object = self._data.get({})
-        if key in storage_object:
-            del storage_object[key]
-            self._data.set(storage_object)
+        if key in self._data:
+            del self._data[key]
         else:
             raise AttributeError(f"{self!r} object has no attribute {key!r}")
 
@@ -82,12 +83,15 @@ class Local:
     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

{asgiref-3.8.1 → asgiref-3.9.0}/asgiref/server.py

@@ -57,12 +57,28 @@ class StatelessServer:
         Runs the asyncio event loop with our handler loop.
         """
         event_loop = asyncio.get_event_loop()
-        asyncio.ensure_future(self.application_checker())
         try:
-            event_loop.run_until_complete(self.handle())
+            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()")
 

{asgiref-3.8.1 → asgiref-3.9.0}/asgiref/sync.py

@@ -179,15 +179,14 @@ class AsyncToSync(Generic[_P, _R]):
 
         # You can't call AsyncToSync from a thread with a running event loop
         try:
-            event_loop = asyncio.get_running_loop()
+            asyncio.get_running_loop()
         except RuntimeError:
             pass
         else:
-            if event_loop.is_running():
-                raise RuntimeError(
-                    "You cannot use AsyncToSync in the same thread as an async event loop - "
-                    "just await the async function directly."
-                )
+            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()
@@ -196,7 +195,7 @@ class AsyncToSync(Generic[_P, _R]):
         # 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()
+        current_executor = CurrentThreadExecutor(old_executor)
         self.executors.current = current_executor
 
         # Wrapping context in list so it can be reassigned from within
@@ -207,7 +206,6 @@ class AsyncToSync(Generic[_P, _R]):
         # an asyncio.CancelledError to.
         task_context = getattr(SyncToAsync.threadlocal, "task_context", None)
 
-        loop = 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.
@@ -217,35 +215,45 @@ class AsyncToSync(Generic[_P, _R]):
                 sys.exc_info(),
                 task_context,
                 context,
-                *args,
-                **kwargs,
+                # 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),
             )
 
-            if not (self.main_event_loop and self.main_event_loop.is_running()):
-                # Make our own event loop - in a new thread - and run inside that.
-                loop = asyncio.new_event_loop()
+            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(
-                    self._run_event_loop, loop, awaitable
-                )
-                if current_executor:
-                    # Run the CurrentThreadExecutor until the future is done
-                    current_executor.run_until_future(loop_future)
+                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()
-            else:
-                # Call it inside the existing loop
-                self.main_event_loop.call_soon_threadsafe(
-                    self.main_event_loop.create_task, awaitable
-                )
-                if current_executor:
-                    # Run the CurrentThreadExecutor until the future is done
-                    current_executor.run_until_future(call_result)
         finally:
-            # Clean up any executor we were running
-            if loop is not None:
-                del self.loop_thread_executors[loop]
             _restore_context(context[0])
             # Restore old current thread executor state
             self.executors.current = old_executor
@@ -253,42 +261,6 @@ class AsyncToSync(Generic[_P, _R]):
         # Wait for results from the future.
         return call_result.result()
 
-    def _run_event_loop(self, loop, coro):
-        """
-        Runs the given event loop (designed to be called in a thread).
-        """
-        asyncio.set_event_loop(loop)
-        try:
-            loop.run_until_complete(coro)
-        finally:
-            try:
-                # mimic asyncio.run() behavior
-                # cancel unexhausted async generators
-                tasks = asyncio.all_tasks(loop)
-                for task in tasks:
-                    task.cancel()
-
-                async def gather():
-                    await asyncio.gather(*tasks, return_exceptions=True)
-
-                loop.run_until_complete(gather())
-                for task in tasks:
-                    if task.cancelled():
-                        continue
-                    if task.exception() is not None:
-                        loop.call_exception_handler(
-                            {
-                                "message": "unhandled exception during loop shutdown",
-                                "exception": task.exception(),
-                                "task": task,
-                            }
-                        )
-                if hasattr(loop, "shutdown_asyncgens"):
-                    loop.run_until_complete(loop.shutdown_asyncgens())
-            finally:
-                loop.close()
-                asyncio.set_event_loop(self.main_event_loop)
-
     def __get__(self, parent: Any, objtype: Any) -> Callable[_P, _R]:
         """
         Include self for methods
@@ -302,8 +274,7 @@ class AsyncToSync(Generic[_P, _R]):
         exc_info: "OptExcInfo",
         task_context: "Optional[List[asyncio.Task[Any]]]",
         context: List[contextvars.Context],
-        *args: _P.args,
-        **kwargs: _P.kwargs,
+        awaitable: Union[Coroutine[Any, Any, _R], Awaitable[_R]],
     ) -> None:
         """
         Wraps the awaitable with something that puts the result into the
@@ -326,9 +297,9 @@ class AsyncToSync(Generic[_P, _R]):
                 try:
                     raise exc_info[1]
                 except BaseException:
-                    result = await self.awaitable(*args, **kwargs)
+                    result = await awaitable
             else:
-                result = await self.awaitable(*args, **kwargs)
+                result = await awaitable
         except BaseException as e:
             call_result.set_exception(e)
         else:

{asgiref-3.8.1 → asgiref-3.9.0}/asgiref/testing.py

@@ -13,18 +13,40 @@ class ApplicationCommunicator:
     """
 
     def __init__(self, application, scope):
+        self._future = None
         self.application = guarantee_single_callable(application)
         self.scope = scope
-        self.input_queue = asyncio.Queue()
-        self.output_queue = asyncio.Queue()
-        # 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(scope, self.input_queue.get, self.output_queue.put),
-        )
+        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):
         """
@@ -46,11 +68,15 @@ class ApplicationCommunicator:
                     pass
 
     def stop(self, exceptions=True):
-        if not self.future.done():
-            self.future.cancel()
+        future = self._future
+        if future is None:
+            return
+
+        if not future.done():
+            future.cancel()
         elif exceptions:
             # Give a chance to raise any exceptions
-            self.future.result()
+            future.result()
 
     def __del__(self):
         # Clean up on deletion
@@ -64,6 +90,10 @@ class ApplicationCommunicator:
         """
         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)
 
@@ -94,6 +124,10 @@ class ApplicationCommunicator:
         """
         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:

{asgiref-3.8.1 → asgiref-3.9.0}/asgiref/typing.py

@@ -189,6 +189,7 @@ class WebSocketResponseBodyEvent(TypedDict):
 class WebSocketDisconnectEvent(TypedDict):
     type: Literal["websocket.disconnect"]
     code: int
+    reason: Optional[str]
 
 
 class WebSocketCloseEvent(TypedDict):

{asgiref-3.8.1 → asgiref-3.9.0/asgiref.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: asgiref
-Version: 3.8.1
+Version: 3.9.0
 Summary: ASGI specs, helper code, and adapters
 Home-page: https://github.com/django/asgiref/
 Author: Django Software Foundation
@@ -17,19 +17,20 @@ 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.8
 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.8
+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>=0.800; extra == "tests"
+Requires-Dist: mypy>=1.14.0; extra == "tests"
+Dynamic: license-file
 
 asgiref
 =======
@@ -129,7 +130,7 @@ file handles for incoming POST bodies).
 Dependencies
 ------------
 
-``asgiref`` requires Python 3.8 or higher.
+``asgiref`` requires Python 3.9 or higher.
 
 
 Contributing
@@ -179,7 +180,7 @@ Then, build and push the packages::
 
     python -m build
     twine upload dist/*
-    rm -r build/ dist/
+    rm -r asgiref.egg-info dist
 
 
 Implementation Details

{asgiref-3.8.1 → asgiref-3.9.0}/asgiref.egg-info/SOURCES.txt

@@ -22,6 +22,7 @@ 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

{asgiref-3.8.1 → asgiref-3.9.0}/asgiref.egg-info/requires.txt

@@ -5,4 +5,4 @@ typing_extensions>=4
 [tests]
 pytest
 pytest-asyncio
-mypy>=0.800
+mypy>=1.14.0

{asgiref-3.8.1 → asgiref-3.9.0}/setup.cfg

@@ -16,11 +16,11 @@ classifiers =
 	Programming Language :: Python
 	Programming Language :: Python :: 3
 	Programming Language :: Python :: 3 :: Only
-	Programming Language :: Python :: 3.8
 	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/
@@ -28,7 +28,7 @@ project_urls =
 	Changelog = https://github.com/django/asgiref/blob/master/CHANGELOG.txt
 
 [options]
-python_requires = >=3.8
+python_requires = >=3.9
 packages = find:
 include_package_data = true
 install_requires = 
@@ -39,11 +39,12 @@ zip_safe = false
 tests = 
 	pytest
 	pytest-asyncio
-	mypy>=0.800
+	mypy>=1.14.0
 
 [tool:pytest]
 testpaths = tests
 asyncio_mode = strict
+asyncio_default_fixture_loop_scope = function
 
 [flake8]
 exclude = venv/*,tox/*,specs/*

asgiref-3.9.0/tests/test_garbage_collection.py

@@ -0,0 +1,55 @@
+import gc
+
+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()
+
+
+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()

{asgiref-3.8.1 → asgiref-3.9.0}/tests/test_local.py

@@ -1,6 +1,7 @@
 import asyncio
 import gc
 import threading
+from threading import Thread
 
 import pytest
 
@@ -338,3 +339,39 @@ def test_thread_critical_local_not_context_dependent_in_sync_thread():
     # 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

{asgiref-3.8.1 → asgiref-3.9.0}/tests/test_server.py

@@ -1,8 +1,8 @@
 import asyncio
 import socket as sock
-from functools import partial
 
 import pytest
+import pytest_asyncio
 
 from asgiref.server import StatelessServer
 
@@ -74,8 +74,8 @@ class Client:
         self._sock.close()
 
 
-@pytest.fixture(scope="function")
-def server():
+@pytest_asyncio.fixture(scope="function")
+async def server():
     async def app(scope, receive, send):
         while True:
             msg = await receive()
@@ -92,25 +92,12 @@ async def check_client_msg(client, expected_address, expected_msg):
     assert server_addr == expected_address
 
 
-async def server_auto_close(fut, timeout):
-    """Server run based on run_until_complete. It will block forever with handle
-    function because it is a while True loop without break.  Use this method to close
-    server automatically."""
-    loop = asyncio.get_running_loop()
-    task = asyncio.ensure_future(fut, loop=loop)
-    await asyncio.sleep(timeout)
-    task.cancel()
-
-
-def test_stateless_server(server):
+@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"""
 
-    loop = asyncio.new_event_loop()
-    asyncio.set_event_loop(loop)
-    server.handle = partial(server_auto_close, fut=server.handle(), timeout=1.0)
-
     client1 = Client(name="client1")
     client2 = Client(name="client2")
 
@@ -124,30 +111,35 @@ def test_stateless_server(server):
         await check_client_msg(client2, server.address, b"Welcome")
         await check_client_msg(client2, server.address, b"Hello")
 
-    task1 = loop.create_task(check_client1_behavior())
-    task2 = loop.create_task(check_client2_behavior())
+    class Done(Exception):
+        pass
 
-    server.run()
+    async def do_test():
+        await asyncio.gather(check_client1_behavior(), check_client2_behavior())
+        raise Done
 
-    assert task1.done()
-    assert task2.done()
+    try:
+        await asyncio.gather(server.arun(), do_test())
+    except Done:
+        pass
 
 
-def test_server_delete_instance(server):
+@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."""
-    loop = asyncio.new_event_loop()
-    asyncio.set_event_loop(loop)
-    server.handle = partial(server_auto_close, fut=server.handle(), timeout=1.0)
-
     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
 
-    task = loop.create_task(client1_multiple_register())
-    server.run()
-
-    assert task.done()
+    try:
+        await asyncio.gather(client1_multiple_register(), server.arun())
+    except Done:
+        pass

{asgiref-3.8.1 → asgiref-3.9.0}/tests/test_sync.py

@@ -7,6 +7,7 @@ import time
 import warnings
 from concurrent.futures import ThreadPoolExecutor
 from functools import wraps
+from typing import Any
 from unittest import TestCase
 
 import pytest
@@ -1174,3 +1175,109 @@ async def test_inner_shield_sync_and_async_middleware_sync_task():
         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 '<kwarg>'"
+    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())

asgiref-3.9.0/tests/test_testing.py

@@ -0,0 +1,90 @@
+import 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())

{asgiref-3.8.1 → asgiref-3.9.0}/tox.ini

@@ -1,6 +1,6 @@
 [tox]
 envlist =
-    py{38,39,310,311,312}-{test,mypy}
+    py{38,39,310,311,312,313}-{test,mypy}
     qa
 
 [testenv]

asgiref-3.8.1/asgiref/__init__.py

@@ -1 +0,0 @@
-__version__ = "3.8.1"

asgiref-3.8.1/tests/test_testing.py

@@ -1,45 +0,0 @@
-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