ojin-client 0.1.7.dev4__tar.gz → 0.1.7.dev6__tar.gz

{ojin_client-0.1.7.dev4 → ojin_client-0.1.7.dev6}/PKG-INFO

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

{ojin_client-0.1.7.dev4 → ojin_client-0.1.7.dev6}/ojin/ojin_persona_client.py

@@ -87,7 +87,9 @@ class OjinPersonaClient(IOjinPersonaClient):
         self._receive_task: Optional[asyncio.Task] = None
         self._inference_server_ready: bool = False
         self._cancelled: bool = False
-        self._cancelled_interaction_id: str | None = None
+        self.active_interaction_id: str | None = None
+        self._split_audio_task: Optional[asyncio.Task] = None
+        self._audio_queue: asyncio.Queue[OjinPersonaInteractionInputMessage] = asyncio.Queue()
 
     async def connect(self) -> None:
         """Establish WebSocket connection and authenticate with the service."""
@@ -109,6 +111,7 @@ class OjinPersonaClient(IOjinPersonaClient):
                 )
                 self._running = True
                 self._receive_task = asyncio.create_task(self._receive_messages())
+                self._split_audio_task = asyncio.create_task(self._split_audio())
                 logger.info("Successfully connected to OJIN Persona service")
                 return
         except WebSocketException as e:
@@ -132,12 +135,7 @@ class OjinPersonaClient(IOjinPersonaClient):
             pass
 
         self._running = False
-
-        if self._receive_task:
-            self._receive_task.cancel()
-            with contextlib.suppress(asyncio.CancelledError):
-                await self._receive_task
-            self._receive_task = None   
+        self.active_interaction_id = None
 
         if self._ws:
             try:
@@ -145,6 +143,19 @@ class OjinPersonaClient(IOjinPersonaClient):
             except Exception as e:
                 logger.error("Error closing WebSocket connection: %s", e)
             self._ws = None
+        
+        if self._split_audio_task:
+            self._split_audio_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await self._split_audio_task
+            self._split_audio_task = None
+
+        if self._receive_task:
+            self._receive_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await self._receive_task
+            self._receive_task = None   
+
 
         logger.info("Disconnected from OJIN Persona service")
 
@@ -198,10 +209,19 @@ class OjinPersonaClient(IOjinPersonaClient):
                     logger.error(e)
                     raise
 
-            if not isinstance(message, str):
-                raise Exception("not a know Format")
-
+            # NOTE: str type
+            # TODO: clean when the proxy add structured logs for this error
             if message == "No backend servers available. Please try again later.":
+                await self._message_queue.put(
+                    ErrorResponseMessage(
+                        payload=ErrorResponse(
+                            interaction_id=None,
+                            code="NO_BACKEND_SERVER_AVAILABLE",
+                            message=message,
+                            timestamp=int(time.monotonic() * 1000),
+                        )
+                    )
+                )
                 raise Exception(message)
 
             data = json.loads(message)
@@ -232,10 +252,11 @@ class OjinPersonaClient(IOjinPersonaClient):
                 if isinstance(msg, OjinPersonaSessionReadyMessage):
                     self._inference_server_ready = True
 
+                await self._message_queue.put(msg)
+
                 if isinstance(msg, ErrorResponseMessage):
                     raise RuntimeError(f"Error in Inference Server received: {msg}")
 
-                await self._message_queue.put(msg)
                 logger.info("Received message: %s", msg)
             else:
                 logger.warning("Unknown message type: %s", msg_type)
@@ -263,6 +284,7 @@ class OjinPersonaClient(IOjinPersonaClient):
         if isinstance(message, OjinPersonaCancelInteractionMessage):
             logger.info("Interrupt")
             
+            self._cancelled = True
             cancel_input = CancelInteractionMessage(
                     payload=message.to_proxy_message()
             )
@@ -277,17 +299,16 @@ class OjinPersonaClient(IOjinPersonaClient):
                 except asyncio.QueueEmpty:
                     break
 
-
             self._cancelled = False
-            self._cancelled_interaction_id = message.interaction_id
 
             return
 
         if isinstance(message, StartInteractionMessage):
-            interaction_id = uuid.uuid4()
+            interaction_id = str(uuid.uuid4())
+            self.active_interaction_id = interaction_id
             logger.info("Generate UUID %s", interaction_id)
             interaction_response = StartInteractionResponseMessage(
-                interaction_id=str(interaction_id)
+                interaction_id=interaction_id
             )
             while not self._message_queue.empty():
                 await self._message_queue.get()
@@ -297,14 +318,71 @@ class OjinPersonaClient(IOjinPersonaClient):
         if isinstance(message, OjinPersonaInteractionInputMessage):
             logger.info("InteractionMessage")            
             logger.info(f"Message sent {message.interaction_id}")
+            if message.interaction_id != self.active_interaction_id:
+                return
+
             if not message.audio_int16_bytes:
                 raise ValueError("Audio cannot be empty")
 
+            
+            await self._audio_queue.put(message)
             # Split audio bytes into chunks of max 3200 samples
+            # max_chunk_size = 3200 * 2
+            # audio_chunks = [
+            #     message.audio_int16_bytes[i : i + max_chunk_size]
+            #     for i in range(0, len(message.audio_int16_bytes), max_chunk_size)
+            # ]
+            # logger.info(
+            #     "Split audio into %d chunks of max %d bytes",
+            #     len(audio_chunks), max_chunk_size
+            # )
+
+            # for i, chunk in enumerate(audio_chunks):
+            #     is_last = i == len(audio_chunks) - 1 and message.is_last_input
+            #
+            #     interaction_input = InteractionInput(
+            #         interaction_id=message.interaction_id,
+            #         is_final_input=is_last,
+            #         payload_type="audio",
+            #         payload=chunk,
+            #         timestamp=int(time.monotonic() * 1000),
+            #         params=message.params if i == 0 else None,
+            #     )
+            #     proxy_message = InteractionInputMessage(payload=interaction_input)
+            #     await self._ws.send(proxy_message.to_bytes())
+            return
+
+        logger.error("The message %s is Unknown", message)
+        # TODO: should we close the connection here?
+        await self.close()
+        error = ErrorResponseMessage(
+                payload=ErrorResponse(
+                    interaction_id=message.interaction_id,
+                    code="UNKNOWN",
+                    message="The message is Unknown",
+                    timestamp=int(time.monotonic() * 1000),
+                )
+        )
+        raise Exception(error)
+
+    async def _split_audio(self) -> None:
+        while True:
+            message_audio: OjinPersonaInteractionInputMessage| None = None
+            if self._cancelled:
+                pass
+
+            try:
+                message_audio = self._audio_queue.get_nowait()
+            except asyncio.QueueEmpty:
+                pass
+
+            if message_audio is None:
+                pass
+
             max_chunk_size = 3200 * 2
             audio_chunks = [
-                message.audio_int16_bytes[i : i + max_chunk_size]
-                for i in range(0, len(message.audio_int16_bytes), max_chunk_size)
+                message_audio.audio_int16_bytes[i : i + max_chunk_size]
+                for i in range(0, len(message_audio.audio_int16_bytes), max_chunk_size)
             ]
             logger.info(
                 "Split audio into %d chunks of max %d bytes",
@@ -312,30 +390,20 @@ class OjinPersonaClient(IOjinPersonaClient):
             )
 
             for i, chunk in enumerate(audio_chunks):
-                is_last = i == len(audio_chunks) - 1 and message.is_last_input
+                is_last = i == len(audio_chunks) - 1 and message_audio.is_last_input
 
                 interaction_input = InteractionInput(
-                    interaction_id=message.interaction_id,
+                    interaction_id=message_audio.interaction_id,
                     is_final_input=is_last,
                     payload_type="audio",
                     payload=chunk,
                     timestamp=int(time.monotonic() * 1000),
-                    params=message.params if i == 0 else None,
+                    params=message_audio.params if i == 0 else None,
                 )
                 proxy_message = InteractionInputMessage(payload=interaction_input)
+
                 await self._ws.send(proxy_message.to_bytes())
-            return
 
-        logger.error("The message %s is Unknown", message)
-        await self.close()
-        error = ErrorResponseMessage(
-                payload=ErrorResponse(
-                    code="UNKNOWN",
-                    message="The message is Unknown",
-                    timestamp=int(time.monotonic() * 1000),
-                )
-        )
-        raise Exception(error)
 
     async def receive_message(self) -> BaseModel | None:
         """Receive the next message from the OJIN Persona service.

{ojin_client-0.1.7.dev4 → ojin_client-0.1.7.dev6}/ojin/ojin_persona_messages.py

@@ -168,26 +168,6 @@ class OjinPersonaInteractionInputMessage(OjinPersonaMessage):
         )
 
 
-class ErrorResponsePayload(BaseModel):
-    """Response message informing the client there was an error.
-
-    contains details about the error
-    """
-
-    error: str
-    code: Optional[str] = None
-    timestamp: Optional[int] = None
-
-
-class ErrorResponseMessage(BaseModel):
-    """Response message informing the client there was an error.
-
-    contains details about the error
-    """
-
-    type: str
-    payload: ErrorResponsePayload
-
 
 class IOjinPersonaClient(ABC):
     """Interface for Ojin Persona client communication.
@@ -210,7 +190,7 @@ class IOjinPersonaClient(ABC):
         """
 
     @abstractmethod
-    async def receive_message(self) -> BaseModel:
+    async def receive_message(self) -> BaseModel|None:
         """Receive a message from the server.
 
         Returns:

{ojin_client-0.1.7.dev4 → ojin_client-0.1.7.dev6}/ojin_client.egg-info/PKG-INFO

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

{ojin_client-0.1.7.dev4 → ojin_client-0.1.7.dev6}/pyproject.toml

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