asgiref 3.10.0__tar.gz → 3.11.1__tar.gz

{asgiref-3.10.0/asgiref.egg-info → asgiref-3.11.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: asgiref
-Version: 3.10.0
+Version: 3.11.1
 Summary: ASGI specs, helper code, and adapters
 Home-page: https://github.com/django/asgiref/
 Author: Django Software Foundation

asgiref-3.11.1/asgiref/__init__.py

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

{asgiref-3.10.0 → asgiref-3.11.1}/asgiref/sync.py

@@ -424,6 +424,7 @@ class SyncToAsync(Generic[_P, _R]):
         func: Callable[_P, _R],
         thread_sensitive: bool = True,
         executor: Optional["ThreadPoolExecutor"] = None,
+        context: Optional[contextvars.Context] = None,
     ) -> None:
         if (
             not callable(func)
@@ -431,8 +432,11 @@ class SyncToAsync(Generic[_P, _R]):
             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.func = func
+        self.context = context
+
         self._thread_sensitive = thread_sensitive
         markcoroutinefunction(self)
         if thread_sensitive and executor is not None:
@@ -480,7 +484,7 @@ class SyncToAsync(Generic[_P, _R]):
             # Use the passed in executor, or the loop's default if it is None
             executor = self._executor
 
-        context = contextvars.copy_context()
+        context = contextvars.copy_context() if self.context is None else self.context
         child = functools.partial(self.func, *args, **kwargs)
         func = context.run
         task_context: List[asyncio.Task[Any]] = []
@@ -518,7 +522,8 @@ class SyncToAsync(Generic[_P, _R]):
                 exec_coro.cancel()
             ret = await exec_coro
         finally:
-            _restore_context(context)
+            if self.context is None:
+                _restore_context(context)
             self.deadlock_context.set(False)
 
         return ret
@@ -611,6 +616,7 @@ def sync_to_async(
     *,
     thread_sensitive: bool = True,
     executor: Optional["ThreadPoolExecutor"] = None,
+    context: Optional[contextvars.Context] = None,
 ) -> Callable[[Callable[_P, _R]], Callable[_P, Coroutine[Any, Any, _R]]]:
     ...
 
@@ -621,6 +627,7 @@ def sync_to_async(
     *,
     thread_sensitive: bool = True,
     executor: Optional["ThreadPoolExecutor"] = None,
+    context: Optional[contextvars.Context] = None,
 ) -> Callable[_P, Coroutine[Any, Any, _R]]:
     ...
 
@@ -630,6 +637,7 @@ def sync_to_async(
     *,
     thread_sensitive: bool = True,
     executor: Optional["ThreadPoolExecutor"] = None,
+    context: Optional[contextvars.Context] = None,
 ) -> Union[
     Callable[[Callable[_P, _R]], Callable[_P, Coroutine[Any, Any, _R]]],
     Callable[_P, Coroutine[Any, Any, _R]],
@@ -639,9 +647,11 @@ def sync_to_async(
             f,
             thread_sensitive=thread_sensitive,
             executor=executor,
+            context=context,
         )
     return SyncToAsync(
         func,
         thread_sensitive=thread_sensitive,
         executor=executor,
+        context=context,
     )

{asgiref-3.10.0 → asgiref-3.11.1}/asgiref/wsgi.py

@@ -1,4 +1,5 @@
 import sys
+from collections import defaultdict
 from tempfile import SpooledTemporaryFile
 
 from asgiref.sync import AsyncToSync, sync_to_async
@@ -9,8 +10,9 @@ class WsgiToAsgi:
     Wraps a WSGI application to make it into an ASGI application.
     """
 
-    def __init__(self, wsgi_application):
+    def __init__(self, wsgi_application, duplicate_header_limit=100):
         self.wsgi_application = wsgi_application
+        self.duplicate_header_limit = duplicate_header_limit
 
     async def __call__(self, scope, receive, send):
         """
@@ -18,7 +20,9 @@ class WsgiToAsgi:
         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)
+        await WsgiToAsgiInstance(self.wsgi_application, self.duplicate_header_limit)(
+            scope, receive, send
+        )
 
 
 class WsgiToAsgiInstance:
@@ -26,8 +30,9 @@ class WsgiToAsgiInstance:
     Per-socket instance of a wrapped WSGI application
     """
 
-    def __init__(self, wsgi_application):
+    def __init__(self, wsgi_application, duplicate_header_limit=100):
         self.wsgi_application = wsgi_application
+        self.duplicate_header_limit = duplicate_header_limit
         self.response_started = False
         self.response_content_length = None
 
@@ -84,6 +89,7 @@ class WsgiToAsgiInstance:
             environ["REMOTE_ADDR"] = scope["client"][0]
 
         # Go through headers and make them into environ entries
+        _headers = defaultdict(list)
         for name, value in self.scope.get("headers", []):
             name = name.decode("latin1")
             if name == "content-length":
@@ -94,9 +100,17 @@ class WsgiToAsgiInstance:
                 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
+            if (
+                self.duplicate_header_limit
+                and len(_headers[corrected_name]) >= self.duplicate_header_limit
+            ):
+                raise ValueError(
+                    f"Too many duplicate headers: {corrected_name} exceeds limit of"
+                    f"{self.duplicate_header_limit}"
+                )
+            _headers[corrected_name].append(value)
+        for name, values in _headers.items():
+            environ[name] = ",".join(values)
         return environ
 
     def start_response(self, status, response_headers, exc_info=None):
@@ -138,7 +152,24 @@ class WsgiToAsgiInstance:
         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)
+        try:
+            environ = self.build_environ(self.scope, body)
+        except ValueError:
+            # Return 400 Bad Request if header limit exceeded
+            self.sync_send(
+                {
+                    "type": "http.response.start",
+                    "status": 400,
+                    "headers": [(b"content-type", b"text/plain")],
+                }
+            )
+            self.sync_send(
+                {
+                    "type": "http.response.body",
+                    "body": b"Bad Request: Too many duplicate headers",
+                }
+            )
+            return
         # Run the WSGI app
         bytes_sent = 0
         for output in self.wsgi_application(environ, self.start_response):

{asgiref-3.10.0 → asgiref-3.11.1/asgiref.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: asgiref
-Version: 3.10.0
+Version: 3.11.1
 Summary: ASGI specs, helper code, and adapters
 Home-page: https://github.com/django/asgiref/
 Author: Django Software Foundation

asgiref-3.11.1/tests/test_sync_contextvars.py

@@ -0,0 +1,161 @@
+import asyncio
+import contextvars
+import sys
+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"
+
+
+@pytest.mark.asyncio
+async def test_sync_to_async_contextvars_with_custom_context():
+    """
+    Passing a custom context to `sync_to_async` ensures that changes to context
+    variables within the synchronous function are isolated to the provided
+    context and do not affect the caller's context. Specifically, verifies that
+    modifications to a context variable inside the sync function are reflected
+    only in the custom context and not in the outer context.
+    """
+
+    def sync_function():
+        time.sleep(1)
+        assert foo.get() == "bar"
+        foo.set("baz")
+        return 42
+
+    foo.set("bar")
+    context = contextvars.copy_context()
+
+    async_function = sync_to_async(sync_function, context=context)
+    assert await async_function() == 42
+
+    # Current context remains unchanged.
+    assert foo.get() == "bar"
+
+    # Custom context reflects the changes made within the sync function.
+    assert context.get(foo) == "baz"
+
+
+@pytest.mark.asyncio
+@pytest.mark.skipif(sys.version_info < (3, 11), reason="requires python3.11")
+async def test_sync_to_async_contextvars_with_custom_context_and_parallel_tasks():
+    """
+    Using a custom context with `sync_to_async` and asyncio tasks isolates
+    contextvars changes, leaving the original context unchanged and reflecting
+    all modifications in the custom context.
+    """
+    foo.set("")
+
+    def sync_function():
+        foo.set(foo.get() + "1")
+        return 1
+
+    async def async_function():
+        foo.set(foo.get() + "1")
+        return 1
+
+    context = contextvars.copy_context()
+
+    await asyncio.gather(
+        sync_to_async(sync_function, context=context)(),
+        sync_to_async(sync_function, context=context)(),
+        asyncio.create_task(async_function(), context=context),
+        asyncio.create_task(async_function(), context=context),
+    )
+
+    # Current context remains unchanged
+    assert foo.get() == ""
+
+    # Custom context reflects the changes made within all the gathered tasks.
+    assert context.get(foo) == "1111"
+
+
+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 async 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"
+
+
+@pytest.mark.asyncio
+async def test_sync_to_async_contextvars_with_callable_with_context_attribute():
+    """
+    Tests that a callable object with a `context` attribute
+    can be wrapped with `sync_to_async` without overwriting the `context` attribute
+    and still returns the expected result.
+    """
+    # Define sync Callable
+    class SyncCallable:
+        def __init__(self):
+            # Should not be copied to the SyncToAsync wrapper.
+            self.context = ...
+
+        def __call__(self):
+            return 42
+
+    async_function = sync_to_async(SyncCallable())
+    assert async_function.context is None
+    assert await async_function() == 42

{asgiref-3.10.0 → asgiref-3.11.1}/tests/test_wsgi.py

@@ -315,3 +315,68 @@ async def test_wsgi_multi_body():
     }
 
     assert (await instance.receive_output(1)) == {"type": "http.response.body"}
+
+
+@pytest.mark.asyncio
+async def test_duplicate_header_limit():
+    def wsgi_application(environ, start_response):
+        start_response("200 OK", [])
+        return [b"OK"]
+
+    application = WsgiToAsgi(wsgi_application, duplicate_header_limit=5)
+    instance = ApplicationCommunicator(
+        application,
+        {
+            "type": "http",
+            "http_version": "1.0",
+            "method": "GET",
+            "path": "/",
+            "query_string": b"",
+            "headers": [[b"x-test", b"value"] for _ in range(10)],
+        },
+    )
+    await instance.send_input({"type": "http.request"})
+
+    assert (await instance.receive_output(1)) == {
+        "type": "http.response.start",
+        "status": 400,
+        "headers": [(b"content-type", b"text/plain")],
+    }
+    assert (await instance.receive_output(1)) == {
+        "type": "http.response.body",
+        "body": b"Bad Request: Too many duplicate headers",
+    }
+
+
+@pytest.mark.asyncio
+async def test_duplicate_header_limit_disabled():
+    def wsgi_application(environ, start_response):
+        assert "HTTP_X_TEST" in environ
+        start_response("200 OK", [])
+        return [b"OK"]
+
+    application = WsgiToAsgi(wsgi_application, duplicate_header_limit=None)
+    instance = ApplicationCommunicator(
+        application,
+        {
+            "type": "http",
+            "http_version": "1.0",
+            "method": "GET",
+            "path": "/",
+            "query_string": b"",
+            "headers": [[b"x-test", b"value"] for _ in range(200)],
+        },
+    )
+    await instance.send_input({"type": "http.request"})
+
+    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"OK",
+        "more_body": True,
+    }
+    assert (await instance.receive_output(1)) == {"type": "http.response.body"}

asgiref-3.10.0/asgiref/__init__.py

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

asgiref-3.10.0/tests/test_sync_contextvars.py

@@ -1,76 +0,0 @@
-import 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"