videosdk-plugins-resemble 0.0.26__tar.gz → 0.0.28__tar.gz

{videosdk_plugins_resemble-0.0.26 → videosdk_plugins_resemble-0.0.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: videosdk-plugins-resemble
-Version: 0.0.26
+Version: 0.0.28
 Summary: VideoSDK Agent Framework plugin for Resemble
 Author: videosdk
 License-Expression: Apache-2.0
@@ -12,7 +12,7 @@ Classifier: Topic :: Multimedia :: Sound/Audio
 Classifier: Topic :: Multimedia :: Video
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Python: >=3.11
-Requires-Dist: videosdk-agents>=0.0.26
+Requires-Dist: videosdk-agents>=0.0.28
 Description-Content-Type: text/markdown
 
 # VideoSDK Resemble Plugin

{videosdk_plugins_resemble-0.0.26 → videosdk_plugins_resemble-0.0.28}/pyproject.toml

@@ -21,7 +21,7 @@ classifiers = [
     "Topic :: Scientific/Engineering :: Artificial Intelligence",
 ]
 dependencies = [
-    "videosdk-agents>=0.0.26"
+    "videosdk-agents>=0.0.28"
 ]
 
 [tool.hatch.version]

{videosdk_plugins_resemble-0.0.26 → videosdk_plugins_resemble-0.0.28}/videosdk/plugins/resemble/tts.py

@@ -7,12 +7,14 @@ import httpx
 from dataclasses import dataclass
 
 from videosdk.agents import TTS
+from videosdk.agents.utils import segment_text
 
 RESEMBLE_HTTP_STREAMING_URL = "https://f.cluster.resemble.ai/stream"
 DEFAULT_VOICE_UUID = "55592656"
 DEFAULT_SAMPLE_RATE = 22050
 DEFAULT_PRECISION = "PCM_16"
 
+
 class ResembleTTS(TTS):
     def __init__(
         self,
@@ -26,16 +28,20 @@ class ResembleTTS(TTS):
 
         self.api_key = api_key or os.getenv("RESEMBLE_API_KEY")
         if not self.api_key:
-            raise ValueError("Resemble API key is required. Provide either `api_key` or set `RESEMBLE_API_KEY` environment variable.")
-        
+            raise ValueError(
+                "Resemble API key is required. Provide either `api_key` or set `RESEMBLE_API_KEY` environment variable.")
+
         self.voice_uuid = voice_uuid
         self.precision = precision
 
         self.audio_track = None
         self.loop = None
         self._first_chunk_sent = False
+        self._interrupted = False
+        self._current_synthesis_task: asyncio.Task | None = None
         self._http_client = httpx.AsyncClient(
-            timeout=httpx.Timeout(connect=15.0, read=30.0, write=5.0, pool=5.0),
+            timeout=httpx.Timeout(connect=15.0, read=30.0,
+                                  write=5.0, pool=5.0),
             follow_redirects=True,
         )
 
@@ -49,28 +55,41 @@ class ResembleTTS(TTS):
         **kwargs: Any,
     ) -> None:
         try:
-            if isinstance(text, AsyncIterator):
-                full_text = ""
-                async for chunk in text:
-                    full_text += chunk
-            else:
-                full_text = text
-
             if not self.audio_track or not self.loop:
                 self.emit("error", "Audio track or event loop not set")
                 return
 
-            await self._http_stream_synthesis(full_text)
+            self._interrupted = False
+
+            if isinstance(text, AsyncIterator):
+                async for segment in segment_text(text):
+                    if self._interrupted:
+                        break
+                    await self._synthesize_segment(segment, **kwargs)
+            else:
+                if not self._interrupted:
+                    await self._synthesize_segment(text, **kwargs)
 
         except Exception as e:
             self.emit("error", f"Resemble TTS synthesis failed: {str(e)}")
 
+    async def _synthesize_segment(self, text: str, **kwargs: Any) -> None:
+        """Synthesize a single text segment"""
+        if not text.strip() or self._interrupted:
+            return
+
+        try:
+            await self._http_stream_synthesis(text)
+        except Exception as e:
+            if not self._interrupted:
+                self.emit("error", f"Segment synthesis failed: {str(e)}")
+
     async def _http_stream_synthesis(self, text: str) -> None:
         headers = {
             "Authorization": f"Token {self.api_key}",
             "Content-Type": "application/json",
         }
-        
+
         payload = {
             "voice_uuid": self.voice_uuid,
             "data": text,
@@ -80,9 +99,9 @@ class ResembleTTS(TTS):
 
         try:
             async with self._http_client.stream(
-                "POST", 
+                "POST",
                 RESEMBLE_HTTP_STREAMING_URL,
-                headers=headers, 
+                headers=headers,
                 json=payload
             ) as response:
                 response.raise_for_status()
@@ -91,9 +110,11 @@ class ResembleTTS(TTS):
                 header_processed = False
 
                 async for chunk in response.aiter_bytes():
+                    if self._interrupted:
+                        break
                     if not header_processed:
                         audio_data += chunk
-                        data_pos = audio_data.find(b'data')
+                        data_pos = audio_data.find(b"data")
                         if data_pos != -1:
                             header_size = data_pos + 8
                             audio_data = audio_data[header_size:]
@@ -102,31 +123,38 @@ class ResembleTTS(TTS):
                         if chunk:
                             audio_data += chunk
 
-                if audio_data:
+                if audio_data and not self._interrupted:
                     await self._stream_audio_chunks(audio_data)
-                        
+
         except httpx.HTTPStatusError as e:
-            self.emit("error", f"HTTP error {e.response.status_code}: {e.response.text}")
+            if not self._interrupted:
+                self.emit(
+                    "error", f"HTTP error {e.response.status_code}: {e.response.text}")
         except Exception as e:
-            self.emit("error", f"HTTP streaming synthesis failed: {str(e)}")
+            if not self._interrupted:
+                self.emit(
+                    "error", f"HTTP streaming synthesis failed: {str(e)}")
 
     async def _stream_audio_chunks(self, audio_bytes: bytes) -> None:
         """Stream audio data in chunks for smooth playback """
-        chunk_size = int(self.sample_rate * 1 * 2 * 20 / 1000)  
-        
+        chunk_size = int(self.sample_rate * 1 * 2 * 20 / 1000)
+
         for i in range(0, len(audio_bytes), chunk_size):
+            if self._interrupted:
+                break
+
             chunk = audio_bytes[i:i + chunk_size]
-            
+
             if len(chunk) < chunk_size and len(chunk) > 0:
                 padding_needed = chunk_size - len(chunk)
                 chunk += b'\x00' * padding_needed
-            
+
             if len(chunk) == chunk_size:
                 if not self._first_chunk_sent and self._first_audio_callback:
                     self._first_chunk_sent = True
                     await self._first_audio_callback()
-                
-                self.loop.create_task(self.audio_track.add_new_bytes(chunk))
+
+                asyncio.create_task(self.audio_track.add_new_bytes(chunk))
                 await asyncio.sleep(0.001)
 
     async def aclose(self) -> None:
@@ -135,5 +163,9 @@ class ResembleTTS(TTS):
         await super().aclose()
 
     async def interrupt(self) -> None:
+        """Interrupt TTS synthesis"""
+        self._interrupted = True
+        if self._current_synthesis_task and not self._current_synthesis_task.done():
+            self._current_synthesis_task.cancel()
         if self.audio_track:
             self.audio_track.interrupt()

videosdk_plugins_resemble-0.0.28/videosdk/plugins/resemble/version.py

@@ -0,0 +1 @@
+__version__ = "0.0.28"

videosdk_plugins_resemble-0.0.26/videosdk/plugins/resemble/version.py

@@ -1 +0,0 @@
-__version__ = "0.0.26"