For now, use anyio

pyproject.toml

@@ -9,7 +9,7 @@ license = { file = "LICENSE" }
 authors = [{ name = "Almar Klein" }, { name = "Korijn van Golen" }]
 keywords = ["webgpu", "wgpu", "vulkan", "metal", "DX12", "opengl"]
 requires-python = ">= 3.9"
-dependencies = ["cffi>=1.15.0", "rubicon-objc>=0.4.1; sys_platform == 'darwin'"]
+dependencies = ["cffi>=1.15.0", "rubicon-objc>=0.4.1; sys_platform == 'darwin'", "anyio>=4.6"]
 
 [project.optional-dependencies]
 # For users

tests/test_async.py

@@ -1,4 +1,4 @@
-import asyncio
+import anyio
 
 import pytest
 
@@ -8,7 +8,7 @@
 from wgpu.backends.wgpu_native import WgpuAwaitable
 
 
-@pytest.mark.asyncio
+@pytest.mark.anyio
 @pytest.mark.parametrize("use_async", [False, True])
 async def test_awaitable_async(use_async):
     count = 0
@@ -28,20 +28,20 @@ def poll_function():
     awaitable = WgpuAwaitable("test", callback, finalizer, poll_function)
 
     if use_async:
-        result = await awaitable
+        result = await awaitable.async_wait()
     else:
         result = awaitable.sync_wait()
     assert result == 10 * 10
 
 
-@pytest.mark.asyncio
+@pytest.mark.anyio
 async def test_asynchronous_get_device():
     adapter = await wgpu.gpu.request_adapter_async(power_preference="high-performance")
     device = await adapter.request_device_async()
     assert device is not None
 
 
-@pytest.mark.asyncio
+@pytest.mark.anyio
 async def test_asynchronous_buffer_map():
     device = wgpu.utils.get_default_device()
 
@@ -63,7 +63,7 @@ async def test_asynchronous_buffer_map():
     assert bytes(data2) == data
 
 
-@pytest.mark.asyncio
+@pytest.mark.anyio
 async def test_asynchronous_make_pipeline():
     device = wgpu.utils.get_default_device()
 
@@ -79,17 +79,28 @@ async def test_asynchronous_make_pipeline():
 
     shader = device.create_shader_module(code=shader_source)
 
-    compute_pipeline, render_pipeline = await asyncio.gather(
-        device.create_compute_pipeline_async(layout="auto", compute={"module": shader}),
-        device.create_render_pipeline_async(
-            layout="auto",
-            vertex={
-                "module": shader,
-            },
-            depth_stencil={"format": TextureFormat.rgba8unorm},
-        ),
-    )
-
+    results = [None, None]
+    async with anyio.create_task_group() as tg:
+        # It's unfortunate anyio doesn't have async.gather. This code would just be
+        # compute_pipeline, render_pipeline = asyncio.gather(.....)
+        async def create_compute_pipeline():
+            results[0] = await device.create_compute_pipeline_async(
+                layout="auto", compute={"module": shader}
+            )
+
+        async def create_render_pipeline():
+            results[1] = await device.create_render_pipeline_async(
+                layout="auto",
+                vertex={
+                    "module": shader,
+                },
+                depth_stencil={"format": TextureFormat.rgba8unorm},
+            )
+
+        tg.start_soon(create_compute_pipeline)
+        tg.start_soon(create_render_pipeline)
+
+    compute_pipeline, render_pipeline = results
     assert compute_pipeline is not None
     assert render_pipeline is not None
 

wgpu/backends/wgpu_native/_api.py

@@ -357,7 +357,7 @@ async def request_adapter_async(
             force_fallback_adapter=force_fallback_adapter,
             canvas=canvas,
         )  # no-cover
-        return await awaitable
+        return await awaitable.async_wait()
 
     def _request_adapter(
         self, *, power_preference=None, force_fallback_adapter=False, canvas=None
@@ -873,7 +873,7 @@ async def request_device_async(
         )
         # Note that although we claim this function is async, the callback always
         # happens inside the call to libf.wgpuAdapterRequestDevice
-        return await awaitable
+        return await awaitable.async_wait()
 
     def _request_device(
         self,
@@ -1602,7 +1602,7 @@ def finalizer(id):
             self._internal, descriptor, callback, ffi.NULL
         )
 
-        return await awaitable
+        return await awaitable.async_wait()
 
     def _create_compute_pipeline_descriptor(
         self,
@@ -1703,7 +1703,7 @@ def finalizer(id):
             self._internal, descriptor, callback, ffi.NULL
         )
 
-        return await awaitable
+        return await awaitable.async_wait()
 
     def _create_render_pipeline_descriptor(
         self,
@@ -2079,7 +2079,7 @@ async def map_async(
         self, mode: flags.MapMode, offset: int = 0, size: Optional[int] = None
     ):
         awaitable = self._map(mode, offset, size)  # for now
-        return await awaitable
+        return await awaitable.async_wait()
 
     def _map(self, mode, offset=0, size=None):
         sync_on_read = True
@@ -3539,7 +3539,7 @@ def on_submitted_work_done_sync(self):
 
     async def on_submitted_work_done_async(self):
         awaitable = self._on_submitted_word_done()
-        await awaitable
+        await awaitable.async_wait()
 
     def _on_submitted_word_done(self):
         @ffi.callback("void(WGPUQueueWorkDoneStatus, void*)")

wgpu/backends/wgpu_native/_helpers.py

@@ -5,6 +5,8 @@
 import time
 from queue import deque
 
+import anyio
+
 from ._ffi import ffi, lib, lib_path
 from ..._diagnostics import DiagnosticsBase
 from ...classes import (
@@ -241,13 +243,16 @@ def __init__(self, title, callback, finalizer, poll_function=None, timeout=5.0):
         self.finalizer = finalizer  # function to finish the result
         self.poll_function = poll_function  # call this to poll wgpu
         self.maxtime = time.perf_counter() + float(timeout)
+        self.event = anyio.Event()
         self.result = None
 
     def set_result(self, result):
         self.result = (result, None)
+        self.event.set()
 
     def set_error(self, error):
         self.result = (None, error)
+        self.event.set()
 
     def sync_wait(self):
         if not self.poll_function:
@@ -258,13 +263,14 @@ def sync_wait(self):
                 time.sleep(self.SLEEP_TIME)
         return self.finish()
 
-    def __await__(self):
+    async def async_wait(self):
         if not self.poll_function:
             if self.result is None:
                 raise RuntimeError("Expected callback to have already happened")
         else:
             while not self._is_done():
-                yield None
+                with anyio.move_on_after(self.SLEEP_TIME):
+                    self.event.wait()
         return self.finish()
 
     def _is_done(self):