webgpu 1.2.1.dev0__py3-none-any.whl → 1.2.2.dev0__py3-none-any.whl

webgpu/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.2.1.dev0'
-__version_tuple__ = version_tuple = (1, 2, 1, 'dev0')
+__version__ = version = '1.2.2.dev0'
+__version_tuple__ = version_tuple = (1, 2, 2, 'dev0')
 
-__commit_id__ = commit_id = 'g7d909a7c5'
+__commit_id__ = commit_id = 'gb9e08e45e'

webgpu/canvas.py

@@ -147,10 +147,12 @@ class Canvas:
         self.update_html_canvas(canvas)
 
     def __del__(self):
-        if self._resize_observer is not None:
-            self._resize_observer.disconnect()
-        if self._intersection_observer is not None:
-            self._intersection_observer.disconnect()
+        disconnect = getattr(self._resize_observer, "disconnect", None)
+        if callable(disconnect):
+            disconnect()
+        disconnect = getattr(self._intersection_observer, "disconnect", None)
+        if callable(disconnect):
+            disconnect()
 
     def update_html_canvas(self, html_canvas):
         """Reconfigure the canvas with the current HTML canvas element. This is necessary when the HTML canvas element changes, disappears (e.g. when switching a tab) and appears again."""

webgpu/link/base.py

@@ -475,13 +475,13 @@ class LinkBaseAsync(LinkBase):
     _callback_loop: asyncio.AbstractEventLoop
     _callback_queue: asyncio.Queue
     _callback_thread: threading.Thread
+    _callback_task: asyncio.Task | None
 
     def __init__(self):
         super().__init__()
         self._send_loop = asyncio.new_event_loop()
         self._callback_loop = asyncio.new_event_loop()
-        self._callback_queue = asyncio.Queue()
-
+        self._callback_task = None
         self._callback_thread = threading.Thread(target=self._start_callback_thread, daemon=True)
         self._callback_thread.start()
 
@@ -516,7 +516,15 @@ class LinkBaseAsync(LinkBase):
             event = threading.Event()
             self._requests[request_id] = event, key
 
-        asyncio.run_coroutine_threadsafe(self._send_async(data), self._send_loop)
+        coro = self._send_async(data)
+        try:
+            asyncio.run_coroutine_threadsafe(coro, self._send_loop)
+        except RuntimeError:
+            coro.close()
+            # Event loop is closed — connection is dead, clean up and bail.
+            if event:
+                self._requests.pop(request_id, None)
+            return None
         if event:
             event.wait()
             return self._requests.pop(request_id)
@@ -530,16 +538,28 @@ class LinkBaseAsync(LinkBase):
                 try:
                     func, args = await self._callback_queue.get()
                     func(*args)
+                except asyncio.CancelledError:
+                    break
+                except RuntimeError:
+                    break
                 except asyncio.QueueEmpty:
                     pass
                 except Exception as e:
                     print("error in callback", type(e), str(e))
-                # await asyncio.sleep(0.01)
 
         try:
             self._callback_loop = asyncio.new_event_loop()
             asyncio.set_event_loop(self._callback_loop)
-            self._callback_loop.create_task(handle_callbacks())
-            self._callback_loop.run_forever()
+            self._callback_queue = asyncio.Queue()
+            self._callback_task = self._callback_loop.create_task(handle_callbacks())
+            try:
+                self._callback_loop.run_forever()
+            finally:
+                if self._callback_task is not None and not self._callback_task.done():
+                    self._callback_task.cancel()
+                    self._callback_loop.run_until_complete(
+                        asyncio.gather(self._callback_task, return_exceptions=True)
+                    )
+                self._callback_loop.close()
         except Exception as e:
             print("exception in _start_callback_thread", e)

webgpu/link/websocket.py

@@ -22,7 +22,7 @@ class WebsocketLinkBase(LinkBaseAsync):
         self._start_handling_messages = threading.Event()
         self._send_loop = asyncio.new_event_loop()
 
-        self._websocket_thread = threading.Thread(target=self._connect)
+        self._websocket_thread = threading.Thread(target=self._connect, daemon=True)
         self._websocket_thread.start()
 
     def wait_for_server_running(self):
@@ -89,7 +89,7 @@ class WebsocketLinkServer(WebsocketLinkBase):
             self._connection = websocket
             self._event_is_connected.set()
             async for message in websocket:
-                thread = threading.Thread(target=self._on_message, args=(message,))
+                thread = threading.Thread(target=self._on_message, args=(message,), daemon=True)
                 thread.start()
         finally:
             self._connection = None
@@ -118,7 +118,41 @@ class WebsocketLinkServer(WebsocketLinkBase):
             self._send_loop.run_until_complete(start_websocket())
         except Exception as e:
             print("exception in _start_websocket_server", e)
-        print("stopped websocket")
+        finally:
+            pending = [
+                task for task in asyncio.all_tasks(self._send_loop)
+                if not task.done()
+            ]
+            for task in pending:
+                task.cancel()
+            if pending:
+                self._send_loop.run_until_complete(
+                    asyncio.gather(*pending, return_exceptions=True)
+                )
+            self._send_loop.run_until_complete(self._send_loop.shutdown_asyncgens())
+            self._send_loop.run_until_complete(self._send_loop.shutdown_default_executor())
+            self._send_loop.close()
 
     def stop(self):
-        self._send_loop.call_soon_threadsafe(self._stop.set_result, None)
+        try:
+            if not self._stop.done():
+                self._send_loop.call_soon_threadsafe(self._stop.set_result, None)
+        except RuntimeError:
+            pass  # Event loop already closed
+        if threading.current_thread() is not self._websocket_thread:
+            self._websocket_thread.join(timeout=2)
+
+        # Stop the callback event loop so the _callback_thread exits.
+        try:
+            self._callback_loop.call_soon_threadsafe(self._callback_loop.stop)
+        except RuntimeError:
+            pass  # Event loop already closed
+        if threading.current_thread() is not self._callback_thread:
+            self._callback_thread.join(timeout=1)
+
+        # Unblock any threads stuck waiting for websocket RPC responses.
+        for rid, val in list(self._requests.items()):
+            if isinstance(val, tuple):
+                event, key = val
+                if isinstance(event, threading.Event):
+                    event.set()

webgpu/platform.py

@@ -206,3 +206,32 @@ def init_pyodide(link_):
 
     LinkBase.register_serializer(BaseWebGPUHandle, lambda _, v: v.handle)
     LinkBase.register_serializer(BaseWebGPUObject, lambda _, v: v.__dict__ or None)
+
+
+def reset():
+    """Reset the platform globals so that init can be called again.
+
+    Used by test runners that start and stop multiple app instances
+    in the same process.
+    """
+    global js, websocket_server, link, create_proxy, destroy_proxy
+    if websocket_server is not None:
+        try:
+            websocket_server.stop()
+        except RuntimeError:
+            pass  # Event loop already closed
+    js = None
+    websocket_server = None
+    link = None
+    if not is_pyodide:
+        create_proxy = None
+        destroy_proxy = None
+
+    # Reset cached WebGPU device so it is re-requested on the new connection.
+    from . import utils as _utils
+    _utils._device = None
+
+    # Reset the cached font atlas — its GPU texture is tied to the old
+    # connection and would deadlock when accessed on a new one.
+    from . import font as _font
+    _font._default_font_atlas = None

webgpu/scene.py

@@ -97,7 +97,13 @@ class Scene:
             self.options.timestamp = time.time()
             self.options.update_buffers()
             for obj in self.render_objects:
-                obj._update_and_create_render_pipeline(self.options)
+                if not obj.active:
+                    continue
+                try:
+                    obj._update_and_create_render_pipeline(self.options)
+                except Exception as e:
+                    print(f'Warning: failed to init renderer {type(obj).__name__}: {e}')
+                    obj.active = False
 
             camera = self.options.camera
             self._js_render = platform.create_proxy(self._render_direct)
@@ -308,8 +314,11 @@ class Scene:
                 self.options.camera._render_function = None
                 self.options.camera._get_position_function = None
                 self.input_handler.unregister_callbacks()
-                platform.destroy_proxy(self._js_render)
-                del self._js_render
-                self.canvas._on_resize_callbacks.remove(self.render)
-                self.canvas._on_update_html_canvas.remove(self.__on_update_html_canvas)
+                if hasattr(self, '_js_render'):
+                    platform.destroy_proxy(self._js_render)
+                    del self._js_render
+                if self.render in self.canvas._on_resize_callbacks:
+                    self.canvas._on_resize_callbacks.remove(self.render)
+                if self.__on_update_html_canvas in self.canvas._on_update_html_canvas:
+                    self.canvas._on_update_html_canvas.remove(self.__on_update_html_canvas)
                 self.canvas = None

webgpu/vectors.py

@@ -31,13 +31,8 @@ class BaseVectorRenderer(Renderer):
         super().__init__(label=label)
         self.gpu_objects.colormap = Colormap()
 
-    def update(self, timestamp):
-        if timestamp == self._timestamp:
-            return
-        self._timestamp = timestamp
-
-        self.gpu_objects.colormap.options = self.options
-        self.gpu_objects.colormap.update(timestamp)
+    def update(self, options):
+        pass
 
     def get_bindings(self):
         return [
@@ -68,9 +63,7 @@ class VectorRenderer(BaseVectorRenderer):
         )
         self.size = size or 1 / 10 * np.linalg.norm(self.bounding_box[1] - self.bounding_box[0])
 
-    def update(self, timestamp):
-        super().update(timestamp)
-
+    def update(self, options):
         self._buffers = {
             "points": buffer_from_array(self.points),
             "vectors": buffer_from_array(self.vectors),

{webgpu-1.2.1.dev0.dist-info → webgpu-1.2.2.dev0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webgpu
-Version: 1.2.1.dev0
+Version: 1.2.2.dev0
 Summary: A Python based WebGPU API using pyodide
 Author-email: Matthias Hochsteger <mhochsteger@cerbsim.com>, Christopher Lackner <clackner@cerbsim.com>
 License-Expression: LGPL-2.1-or-later

{webgpu-1.2.1.dev0.dist-info → webgpu-1.2.2.dev0.dist-info}/RECORD

@@ -1,7 +1,7 @@
 webgpu/__init__.py,sha256=h0nQ2lBaCOWz6UpveZuFnJophgAKbVFUsL2QO1_uoTw,302
-webgpu/_version.py,sha256=wn-w5PgTjiNi-tEtjZzaAv8vvCbjnxBePaSba7V9LaY,541
+webgpu/_version.py,sha256=nSwG2ivutkcNO6WO5b1Wwu5l2YnLq5Jz8hN6lYWD6v0,541
 webgpu/camera.py,sha256=jt4SNNtmZhy4PfbTlGvY30eEwy3wkckjmiTA0s8QrtE,11125
-webgpu/canvas.py,sha256=PlrJQQtv32YPBakkZnOvMYcJ_HYi_4iW4ZPIm9eYXnA,12165
+webgpu/canvas.py,sha256=GRQ96ENrFDyiTQQcX4_1Q-yeHWdn8hsocMbIeYOXd5g,12233
 webgpu/clipping.py,sha256=RituZ-WJdUX7IubAhGORfQ5NM56QnsMau3G9ld2F6fI,4066
 webgpu/colormap.py,sha256=FwpEZE1MU-ws8TndYpvFl_VaBR1U_bw6pbsYxaueSZM,13169
 webgpu/draw.py,sha256=0JRBRf0HcA6O8yTGYXCnI8TvnhVMjn4VZ8mFQp9xO4M,555
@@ -13,21 +13,21 @@ webgpu/jupyter_pyodide.py,sha256=e7u8nvUwfHF6ME07RAiO8L-oto7owyBzwsa2RBJIh0I,969
 webgpu/labels.py,sha256=OSYvBvjjXRIX4fPOcAtDt6Xk6GdI1ghekOLIIYxNIhg,4209
 webgpu/light.py,sha256=sideBOi2vSWj1OJUvhCTG47N8S06GhkJAUBnfGGgaqA,2798
 webgpu/lilgui.py,sha256=xLOrt3RZEMNXO4OgSnBcZZXelLRYdg3laKIMpqBHyIM,1979
-webgpu/platform.py,sha256=7QsdlTzWDZrSpAXmjux_zRoKWjk2l7gOjXnlna8ZogA,6043
+webgpu/platform.py,sha256=OaDxjAJaHEHZcd1DUYMxZDP2a72gnYZpQncym_RVLvI,6940
 webgpu/renderer.py,sha256=6fwj9VpR22FrV2Ua3F5Etdt1zli8MeXHknFQfBUTdMA,12482
-webgpu/scene.py,sha256=J3jHX9grPGTJpi64nLASZv-DcGIq-OwMtCo_-_QUUqY,11695
+webgpu/scene.py,sha256=Si_XpQiuuDv3h6bss75kAZnRNN30hgtEzyDkEvxgdd4,12170
 webgpu/shapes.py,sha256=Yf-ca0iZm_cAb0l4T95ZM1JCB1CXoqkzFT8mQPxA0vM,15716
 webgpu/testing.py,sha256=z25Q_mO-HzdedFDmd2JXHemK3Hl_shQQ42IBTRLKTR0,13014
 webgpu/triangles.py,sha256=EVYU6kjz56LJCVEXeOE6ZEaa4oZ9RPeYdf_-hXMneoY,1865
 webgpu/uniforms.py,sha256=5wm06tjZsEAtIxkdCe-5W0hQl3yFc6w4V-X_2SQIa1A,3031
 webgpu/utils.py,sha256=pV9j8Os-XV79TPcKri_WQqUnv9ST_Dim__JoHzBKS6o,20038
-webgpu/vectors.py,sha256=SEXGvdOPQHXbYuMWvpjH_wJqMEgd3tEu7l9ZX5X4OGM,2970
+webgpu/vectors.py,sha256=tjPijM9npqhz_Mu-2qzI_61ZQPnBC7nf8-t-Z9c2o_M,2738
 webgpu/webgpu_api.py,sha256=EgudES5MxMWMZHKovF9-bnfNEWyCQPTQkXNiXFh6l9s,51491
 webgpu/link/__init__.py,sha256=3i6KrP6iOJFJSm7_VUTdLV91A0h8qXNtuUiaEsxoS3I,107
-webgpu/link/base.py,sha256=H5VUGkgNZFb4SZCBX2_r8HJEZREeALiVkKAG1qjaWGI,17874
+webgpu/link/base.py,sha256=n_zd8rNvXKp_UY64S0X-haXKAS4jseVomBHBv-OE1fY,18722
 webgpu/link/link.js,sha256=kN4csmhMvinnVwskITgOceQcvPpOVoqg6jEQD0hdD3A,19225
 webgpu/link/proxy.py,sha256=FdnKKpudTJGjzchPuOkiDrx4wj5HosrUPGfZaw7rgOU,2519
-webgpu/link/websocket.py,sha256=Rr-QBSGJMt9jvW7jp4KbUWNjDtdcq201yR7u8Bhdrn4,3852
+webgpu/link/websocket.py,sha256=DfSfGSSDwTFGSbEAc9yTVRDOvkYwRZ8UIs_oGo7pY30,5337
 webgpu/shaders/camera.wgsl,sha256=zryLSCd_rF04oC5WeNbNgETCzUM-40O6HAT_ksc9e2s,704
 webgpu/shaders/clipping.wgsl,sha256=XiSITaxuJtNHUrJ-Z8qpXgtFS8K4u-NXiobhm0V5xkQ,1049
 webgpu/shaders/colormap.wgsl,sha256=l6VEGD3ap-cB3168nENCNoypa0bMfPD8AnSXVstC_r0,2195
@@ -37,8 +37,8 @@ webgpu/shaders/shapes.wgsl,sha256=g6ZzqSP_ngfh575ed6s-D3BtGbdC53a0f7DZV90PC0k,29
 webgpu/shaders/text.wgsl,sha256=25jld-LVAGIJbYiPIiSWWrzL_l2zWUHpu9a0C7_JvaA,2204
 webgpu/shaders/triangulation.wgsl,sha256=EFMDTdvI7PJ1Fgrg4LQi5bUYRp-TLeZYhUDpkMDj6OA,1340
 webgpu/shaders/vector.wgsl,sha256=SJL_d8fky_lzFOL-YyJoAqad5mbuBHEPnBW_0fRBLzo,3862
-webgpu-1.2.1.dev0.dist-info/licenses/LICENSE,sha256=oZDcnIBDdV2Q-LCnX6ZrnkLUr0yYC_XdxjPwEk2zzuc,26430
-webgpu-1.2.1.dev0.dist-info/METADATA,sha256=Z4eSyfmNkvyejUBsq0iYIIaqEVHTDiJTCOL5hRZ_F6A,3477
-webgpu-1.2.1.dev0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-webgpu-1.2.1.dev0.dist-info/top_level.txt,sha256=x6CotXenAnd3P6fHgyUW3ezc05V65HLlYqqMHbA7kYQ,7
-webgpu-1.2.1.dev0.dist-info/RECORD,,
+webgpu-1.2.2.dev0.dist-info/licenses/LICENSE,sha256=oZDcnIBDdV2Q-LCnX6ZrnkLUr0yYC_XdxjPwEk2zzuc,26430
+webgpu-1.2.2.dev0.dist-info/METADATA,sha256=LRYVYTjQNOhnwcNnlSbgtdAOZV_F4DcflH1Fa2XeD0k,3477
+webgpu-1.2.2.dev0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+webgpu-1.2.2.dev0.dist-info/top_level.txt,sha256=x6CotXenAnd3P6fHgyUW3ezc05V65HLlYqqMHbA7kYQ,7
+webgpu-1.2.2.dev0.dist-info/RECORD,,