@camera.ui/server 0.0.105 → 0.0.107

package/dist/server/src/_camera_ui_tools/camera_ui_rpc/channel.py

@@ -30,9 +30,11 @@ class Channel:
         self._closed: bool = False
         self._initialized: bool = False
         self._unsubscribe: Callable[[], Coroutine[Any, Any, None]] | None = None
-        self.__handlers: dict[str, set[Callable[[Any], None | Awaitable[None]]]] = {}
-        self.__close_handlers: set[Callable[[], None | Awaitable[None]]] = set()
-        self.__error_handlers: set[Callable[[Exception], None | Awaitable[None]]] = set()
+        # Handler registries map handler -> is_async, so the async-ness is
+        # determined once at registration instead of per emitted message.
+        self.__handlers: dict[str, dict[Callable[[Any], None | Awaitable[None]], bool]] = {}
+        self.__close_handlers: dict[Callable[[], None | Awaitable[None]], bool] = {}
+        self.__error_handlers: dict[Callable[[Exception], None | Awaitable[None]], bool] = {}
         self.__subscriptions: list[Callable[[], Coroutine[Any, Any, None]]] = []
         self.__isolated_client: RPCClient | None = None
 
@@ -96,14 +98,15 @@ class Channel:
     def on(self, event: Literal["error"], handler: Callable[[Exception], None | Awaitable[None]]) -> None: ...
     def on(self, event: str, handler: Callable[..., None | Awaitable[None]]) -> None:
         """Listen for events."""
+        handler_is_async = is_async_function(handler)
         if event == "close":
-            self.__close_handlers.add(handler)
+            self.__close_handlers[handler] = handler_is_async
         elif event == "error":
-            self.__error_handlers.add(handler)
+            self.__error_handlers[handler] = handler_is_async
         else:
             if event not in self.__handlers:
-                self.__handlers[event] = set()
-            self.__handlers[event].add(handler)
+                self.__handlers[event] = {}
+            self.__handlers[event][handler] = handler_is_async
 
     @overload
     def off(self, event: Literal["message"], handler: Callable[[Any], None | Awaitable[None]]) -> None: ...
@@ -116,12 +119,12 @@ class Channel:
     def off(self, event: str, handler: Callable[..., None | Awaitable[None]]) -> None:
         """Remove event listener."""
         if event == "close":
-            self.__close_handlers.discard(handler)
+            self.__close_handlers.pop(handler, None)
         elif event == "error":
-            self.__error_handlers.discard(handler)
+            self.__error_handlers.pop(handler, None)
         else:
             if event in self.__handlers:
-                self.__handlers[event].discard(handler)
+                self.__handlers[event].pop(handler, None)
 
     async def close(self) -> None:
         """Close the channel gracefully."""
@@ -142,15 +145,20 @@ class Channel:
         await self._cleanup()
 
     async def _emit(self, event: str, data: Any = None) -> None:
-        """Emit an event to handlers."""
+        """Emit an event to handlers.
+
+        Sync handlers run inline on the event loop — the thread-pool hop
+        costs far more than the short callbacks used here and would break
+        per-channel message ordering.
+        """
         if event in self.__handlers:
-            for handler in self.__handlers[event]:
+            # Snapshot: an inline handler may add/remove listeners re-entrantly.
+            for handler, handler_is_async in list(self.__handlers[event].items()):
                 try:
-                    if is_async_function(handler):
+                    if handler_is_async:
                         await handler(data)  # type: ignore[misc]
                     else:
-                        loop = asyncio.get_event_loop()
-                        await loop.run_in_executor(self._client.io_pool, handler, data)
+                        handler(data)
                 except Exception as e:
                     print(f"Error in channel handler: {e}")
 
@@ -161,25 +169,23 @@ class Channel:
 
         self._closed = True
 
-        for handler in self.__close_handlers:
+        for handler, handler_is_async in list(self.__close_handlers.items()):
             with contextlib.suppress(Exception):
-                if is_async_function(handler):
+                if handler_is_async:
                     await handler()  # type: ignore[misc]
                 else:
-                    loop = asyncio.get_event_loop()
-                    await loop.run_in_executor(self._client.io_pool, handler)
+                    handler()
 
         asyncio.create_task(self._cleanup())
 
     async def _handle_error(self, error: Exception) -> None:
         """Handle channel error."""
-        for handler in self.__error_handlers:
+        for handler, handler_is_async in list(self.__error_handlers.items()):
             with contextlib.suppress(Exception):
-                if is_async_function(handler):
+                if handler_is_async:
                     await handler(error)  # type: ignore[misc]
                 else:
-                    loop = asyncio.get_event_loop()
-                    await loop.run_in_executor(self._client.io_pool, handler, error)
+                    handler(error)
 
     async def _cleanup(self) -> None:
         """Clean up resources."""

package/dist/server/src/_camera_ui_tools/camera_ui_rpc/chunking.py

@@ -1,9 +1,10 @@
 """Optimized chunking system for large message handling."""
 
+import time
 from collections.abc import Callable, Generator
 from typing import Any
 
-from .codec import decode
+from .codec import decode_message
 from .types import ChunkData
 
 
@@ -152,10 +153,13 @@ class ChunkAssembler:
             raise RuntimeError("Cannot get data: Not all chunks have been received.")
 
         if self.buffer is not None:
-            # Optimal path: The buffer is already fully assembled.
-            # We create a memoryview to avoid copying the buffer before decoding.
+            # Optimal path: The buffer is already fully assembled. Chunked
+            # payloads are always full wire messages, so this goes through
+            # decode_message: a reassembled CUIB frame yields zero-copy
+            # memoryview slices into the assembly buffer (the views keep the
+            # bytearray alive after the assembler is pooled/reset).
             data_view = memoryview(self.buffer)
-            return decode(data_view)
+            return decode_message(data_view)
         else:
             # Fallback path: Manually combine chunks from temporary storage.
             # This path involves a final copy operation.
@@ -167,7 +171,7 @@ class ChunkAssembler:
                 chunk_len = len(chunk)
                 combined[offset : offset + chunk_len] = chunk
                 offset += chunk_len
-            return decode(combined)
+            return decode_message(combined)
 
     def get_progress(self) -> dict[str, int | float]:
         """Get the current progress of the chunk transfer."""
@@ -180,11 +184,22 @@ class ChunkAssembler:
 class ChunkingManager:
     """Manages multiple concurrent chunk transfers."""
 
+    # Incomplete transfers hold their full pre-allocated buffer. If a single
+    # chunk is lost (sender reconnected mid-transfer), the assembler would
+    # otherwise sit in memory until the whole client disconnects — so stale
+    # transfers are swept lazily on every start_receiving/process_chunk call.
+    _STALE_TRANSFER_TTL: float = 30.0
+    # Sweeping on every chunk of a large transfer is pure overhead — one
+    # sweep per second is more than enough for a 30s TTL.
+    _SWEEP_INTERVAL: float = 1.0
+
     def __init__(self) -> None:
         self.assemblers: dict[str, ChunkAssembler] = {}
         self.completed_callbacks: dict[str, Callable[[Any], None]] = {}
         self.error_callbacks: dict[str, Callable[[Exception], None]] = {}
         self._assembler_pool: list[ChunkAssembler] = []
+        self._last_activity: dict[str, float] = {}
+        self._last_sweep: float = 0.0
 
     def _get_assembler(self, transfer_id: str) -> ChunkAssembler:
         """Get a reusable assembler from a pool or create a new one."""
@@ -228,14 +243,42 @@ class ChunkingManager:
             on_error: Callback to execute if an error occurs.
             total_size: The total size of the final data for pre-allocation.
         """
+        self._sweep_stale()
         assembler = self._get_assembler(transfer_id)
         assembler.set_expected_chunks(total_chunks, total_size, chunk_size)
         self.assemblers[transfer_id] = assembler
         self.completed_callbacks[transfer_id] = on_complete
         self.error_callbacks[transfer_id] = on_error
+        self._last_activity[transfer_id] = time.monotonic()
+
+    def _sweep_stale(self) -> None:
+        """Drop incomplete transfers with no activity for _STALE_TRANSFER_TTL.
+
+        Rate-limited to at most one sweep per _SWEEP_INTERVAL — this runs on
+        every start_receiving/process_chunk call.
+        """
+        if not self._last_activity:
+            return
+        now = time.monotonic()
+        if now - self._last_sweep < self._SWEEP_INTERVAL:
+            return
+        self._last_sweep = now
+        cutoff = now - self._STALE_TRANSFER_TTL
+        stale = [tid for tid, ts in self._last_activity.items() if ts < cutoff]
+        for transfer_id in stale:
+            error_callback = self.error_callbacks.pop(transfer_id, None)
+            assembler = self.assemblers.pop(transfer_id, None)
+            if assembler:
+                self._return_assembler(assembler)
+            self.completed_callbacks.pop(transfer_id, None)
+            self._last_activity.pop(transfer_id, None)
+            if error_callback:
+                error_callback(RuntimeError("Transfer timed out"))
 
     def process_chunk(self, chunk: dict[str, Any]) -> None:
         """Process an incoming chunk for a specific transfer."""
+        self._sweep_stale()
+
         transfer_id = chunk.get("id") or chunk.get("transferId")
         if not transfer_id:
             return
@@ -245,6 +288,8 @@ class ChunkingManager:
             # Received a chunk for an unknown or completed transfer.
             return
 
+        self._last_activity[transfer_id] = time.monotonic()
+
         try:
             # Normalize keys in-place to avoid allocating a new dict.
             # Handles minor key differences between JS/Go/Python senders.
@@ -261,6 +306,7 @@ class ChunkingManager:
                 # Cleanup and return assembler to the pool
                 del self.assemblers[transfer_id]
                 self.error_callbacks.pop(transfer_id, None)
+                self._last_activity.pop(transfer_id, None)
                 self._return_assembler(assembler)
 
                 if callback:
@@ -276,6 +322,7 @@ class ChunkingManager:
         if assembler:
             self._return_assembler(assembler)
         self.completed_callbacks.pop(transfer_id, None)
+        self._last_activity.pop(transfer_id, None)
 
         if error_callback:
             error_callback(error)