ojin-client 0.1.7.dev10__tar.gz → 0.1.7.dev12__tar.gz

{ojin_client-0.1.7.dev10 → ojin_client-0.1.7.dev12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ojin-client
-Version: 0.1.7.dev10
+Version: 0.1.7.dev12
 Summary: Ojin platform services
 Author: Journee
 License: Apache-2.0

{ojin_client-0.1.7.dev10 → ojin_client-0.1.7.dev12}/ojin/ojin_persona_client.py

@@ -1,4 +1,4 @@
-"""WebSocket client for OJIN Persona service with optimized cancellation handling."""
+"""WebSocket client for OJIN Persona service with send buffer management."""
 
 import asyncio
 import contextlib
@@ -91,8 +91,10 @@ class OjinPersonaClient(IOjinPersonaClient):
         self._split_audio_task: Optional[asyncio.Task] = None
         self._audio_queue: asyncio.Queue[OjinPersonaInteractionInputMessage] = asyncio.Queue()
         
-        # Add cancellation event for immediate stopping
+        # Add cancellation event and send queue for managing buffer backpressure
         self._cancel_event = asyncio.Event()
+        self._send_queue: asyncio.Queue = asyncio.Queue(maxsize=100)  # Limit queue size
+        self._send_task: Optional[asyncio.Task] = None
 
     async def connect(self) -> None:
         """Establish WebSocket connection and authenticate with the service."""
@@ -109,12 +111,23 @@ class OjinPersonaClient(IOjinPersonaClient):
 
                 # Add query parameters for API key and config ID
                 url = f"{self.ws_url}?config_id={self.config_id}"
+                # Configure WebSocket with smaller buffers to reduce latency
                 self._ws = await websockets.connect(
-                    url, additional_headers=headers, ping_interval=30, ping_timeout=10
+                    url, 
+                    additional_headers=headers, 
+                    ping_interval=30, 
+                    ping_timeout=10,
+                    # Reduce write buffer size to minimize send blocking
+                    write_limit=16384,  # 16KB instead of default 64KB
+                    # Reduce max message size to prevent large messages from blocking
+                    max_size=1024*1024,  # 1MB max message size
+                    # Reduce queue size to minimize buffering delay
+                    max_queue=8  # Smaller queue than default 32
                 )
                 self._running = True
                 self._receive_task = asyncio.create_task(self._receive_messages())
                 self._split_audio_task = asyncio.create_task(self._split_audio())
+                self._send_task = asyncio.create_task(self._send_worker())
                 logger.info("Successfully connected to OJIN Persona service")
                 return
         except WebSocketException as e:
@@ -141,6 +154,13 @@ class OjinPersonaClient(IOjinPersonaClient):
         self._active_interaction_id = None
         self._cancel_event.set()  # Signal cancellation to all tasks
 
+        # Stop send worker first to prevent new messages
+        if self._send_task:
+            self._send_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await self._send_task
+            self._send_task = None
+
         if self._ws:
             try:
                 await self._ws.close()
@@ -162,6 +182,56 @@ class OjinPersonaClient(IOjinPersonaClient):
 
         logger.info("Disconnected from OJIN Persona service")
 
+    async def _send_worker(self) -> None:
+        """Dedicated worker to send messages without blocking the main thread."""
+        while self._running:
+            try:
+                # Wait for either a message to send or cancellation
+                send_task = asyncio.create_task(self._send_queue.get())
+                cancel_task = asyncio.create_task(self._cancel_event.wait())
+                
+                done, pending = await asyncio.wait(
+                    [send_task, cancel_task],
+                    return_when=asyncio.FIRST_COMPLETED,
+                    timeout=0.1
+                )
+                
+                # Cancel pending tasks
+                for task in pending:
+                    task.cancel()
+                    with contextlib.suppress(asyncio.CancelledError):
+                        await task
+                
+                if self._cancelled or self._cancel_event.is_set():
+                    # Clear send queue during cancellation
+                    while not self._send_queue.empty():
+                        try:
+                            self._send_queue.get_nowait()
+                        except asyncio.QueueEmpty:
+                            break
+                    continue
+                
+                if done and send_task in done:
+                    message_data = send_task.result()
+                    
+                    if self._ws and not self._ws.closed:
+                        try:
+                            # Use asyncio.wait_for to prevent indefinite blocking
+                            await asyncio.wait_for(
+                                self._ws.send(message_data),
+                                timeout=5.0  # 5 second timeout for sends
+                            )
+                        except asyncio.TimeoutError:
+                            logger.error("Send timeout - WebSocket send buffer may be full")
+                            # Don't break the connection, just log and continue
+                        except Exception as e:
+                            logger.error(f"Error sending message: {e}")
+                            break
+                            
+            except Exception as e:
+                logger.error(f"Error in send worker: {e}")
+                break
+
     async def _receive_messages(self) -> None:
         """Continuously receive and process incoming messages."""
         if not self._ws:
@@ -292,21 +362,29 @@ class OjinPersonaClient(IOjinPersonaClient):
             self._cancelled = True
             self._cancel_event.set()
             
-            # Send cancellation message with high priority
+            # Clear all queues immediately
+            self._clear_all_queues()
+            
+            # Send cancellation message directly, bypassing the send queue
             cancel_input = CancelInteractionMessage(
                     payload=message.to_proxy_message()
             )
 
-            # Send immediately without waiting
+            # Send immediately with timeout to prevent blocking
             try:
-                await self._ws.send(cancel_input.model_dump_json())
-                logger.info(f"Cancellation message sent immediately for {message.interaction_id}")
+                if self._ws and not self._ws.closed:
+                    await asyncio.wait_for(
+                        self._ws.send(cancel_input.model_dump_json()),
+                        timeout=1.0  # Short timeout for immediate sending
+                    )
+                    logger.warning(f"Cancellation message sent immediately for {message.interaction_id}")
+            except asyncio.TimeoutError:
+                logger.warning("Cancellation send timeout - forcing connection close")
+                await self.close()
+                return
             except Exception as e:
                 logger.error(f"Failed to send cancellation message: {e}")
 
-            # Clear queues quickly without blocking
-            self._clear_queues_non_blocking()
-
             # Reset cancellation state
             self._cancelled = False
             self._cancel_event.clear()
@@ -321,7 +399,7 @@ class OjinPersonaClient(IOjinPersonaClient):
                 interaction_id=interaction_id
             )
             # Clear queues non-blocking
-            self._clear_queues_non_blocking()
+            self._clear_message_queue()
             self._message_queue.put_nowait(interaction_response)
             return
 
@@ -334,7 +412,11 @@ class OjinPersonaClient(IOjinPersonaClient):
             if not message.audio_int16_bytes:
                 raise ValueError("Audio cannot be empty")
             
-            await self._audio_queue.put(message)
+            # Use put_nowait to prevent blocking - drop messages if queue is full
+            try:
+                self._audio_queue.put_nowait(message)
+            except asyncio.QueueFull:
+                logger.warning("Audio queue full - dropping audio message")
             return
 
         logger.error("The message %s is Unknown", message)
@@ -350,22 +432,36 @@ class OjinPersonaClient(IOjinPersonaClient):
         )
         raise Exception(error)
 
-    def _clear_queues_non_blocking(self) -> None:
+    def _clear_all_queues(self) -> None:
         """Clear all queues without blocking."""
-        # Clear message queue
+        self._clear_message_queue()
+        self._clear_audio_queue()
+        self._clear_send_queue()
+
+    def _clear_message_queue(self) -> None:
+        """Clear message queue without blocking."""
         while True:
             try:
                 self._message_queue.get_nowait()
             except asyncio.QueueEmpty:
                 break
-        
-        # Clear audio queue
+    
+    def _clear_audio_queue(self) -> None:
+        """Clear audio queue without blocking."""
         while True:
             try:
                 self._audio_queue.get_nowait()
             except asyncio.QueueEmpty:
                 break
 
+    def _clear_send_queue(self) -> None:
+        """Clear send queue without blocking."""
+        while True:
+            try:
+                self._send_queue.get_nowait()
+            except asyncio.QueueEmpty:
+                break
+
     async def _split_audio(self) -> None:
         """Split audio into chunks and send them, with cancellation support."""
         while self._running:
@@ -446,10 +542,12 @@ class OjinPersonaClient(IOjinPersonaClient):
                 proxy_message = InteractionInputMessage(payload=interaction_input)
 
                 try:
-                    await self._ws.send(proxy_message.to_bytes())
-                except Exception as e:
-                    logger.error(f"Failed to send audio chunk: {e}")
-                    break
+                    # Use put_nowait to prevent blocking on full send queue
+                    self._send_queue.put_nowait(proxy_message.to_bytes())
+                except asyncio.QueueFull:
+                    logger.warning("Send queue full - dropping audio chunk")
+                    # Continue with next chunk instead of breaking
+                    continue
 
     async def receive_message(self) -> BaseModel | None:
         """Receive the next message from the OJIN Persona service.

{ojin_client-0.1.7.dev10 → ojin_client-0.1.7.dev12}/ojin_client.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ojin-client
-Version: 0.1.7.dev10
+Version: 0.1.7.dev12
 Summary: Ojin platform services
 Author: Journee
 License: Apache-2.0

{ojin_client-0.1.7.dev10 → ojin_client-0.1.7.dev12}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ojin-client"
-version = "0.1.7dev10"
+version = "0.1.7dev12"
 description = "Ojin platform services"
 readme = "README.md"
 requires-python = ">=3.10"