dv-pipecat-ai 0.0.85.dev865__py3-none-any.whl → 0.0.85.dev866__py3-none-any.whl

{dv_pipecat_ai-0.0.85.dev865.dist-info → dv_pipecat_ai-0.0.85.dev866.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-ai
-Version: 0.0.85.dev865
+Version: 0.0.85.dev866
 Summary: An open source framework for voice (and multimodal) assistants
 License-Expression: BSD-2-Clause
 Project-URL: Source, https://github.com/pipecat-ai/pipecat
@@ -33,6 +33,9 @@ Requires-Dist: soxr~=0.5.0
 Requires-Dist: openai<3,>=1.74.0
 Requires-Dist: numba==0.61.2
 Requires-Dist: wait_for2>=0.4.1; python_version < "3.12"
+Requires-Dist: boto3>=1.38.27
+Requires-Dist: aioboto3>=15.0.0
+Requires-Dist: redis>=7.1.0
 Provides-Extra: aic
 Requires-Dist: aic-sdk~=1.0.1; extra == "aic"
 Provides-Extra: anthropic

{dv_pipecat_ai-0.0.85.dev865.dist-info → dv_pipecat_ai-0.0.85.dev866.dist-info}/RECORD

@@ -1,4 +1,4 @@
-dv_pipecat_ai-0.0.85.dev865.dist-info/licenses/LICENSE,sha256=DWY2QGf2eMCFhuu2ChairtT6CB7BEFffNVhXWc4Od08,1301
+dv_pipecat_ai-0.0.85.dev866.dist-info/licenses/LICENSE,sha256=DWY2QGf2eMCFhuu2ChairtT6CB7BEFffNVhXWc4Od08,1301
 pipecat/__init__.py,sha256=j0Xm6adxHhd7D06dIyyPV_GlBYLlBnTAERVvD_jAARQ,861
 pipecat/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pipecat/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -173,7 +173,7 @@ pipecat/services/ai_services.py,sha256=_RrDWfM8adV17atzY9RxK0nXRVM5kbUkKrvN90GAW
 pipecat/services/image_service.py,sha256=tqJun4nYeyN_PaWqTdF_CFsOiqBf3XX7R4et5Y07mEU,2357
 pipecat/services/llm_service.py,sha256=39y9tjrusTr8Zr9sFlg9xz86CXpy39FiyLtsbcbsu8g,25379
 pipecat/services/mcp_service.py,sha256=yS48Uj5qD4jnhYYhs9Kw1aa1cjdYIwxYYjzCc_u6M0o,14345
-pipecat/services/stt_service.py,sha256=oBZ34DLvAoAzYMsWQqywkwy2Wjh_Rjh32k-d7CjffBI,12982
+pipecat/services/stt_service.py,sha256=x07vWXJCKj7TVgR5mXHLU4_nCzZe0jf0XLfS9DGzcWQ,12981
 pipecat/services/tts_service.py,sha256=C1qYmewQ7qzEGd5SyUIISBjknnlhMJzUZ5lRgJgwhII,36540
 pipecat/services/vision_service.py,sha256=v7Ft27xIwECAaL2ZzMZT8wG5aOA-JoUZWx2NxNaJ6pg,2580
 pipecat/services/websocket_service.py,sha256=AWv7CL6G_XAh815xVaKNPpjP5escp8Q880SYHG7kCoI,5745
@@ -317,6 +317,8 @@ pipecat/services/qwen/__init__.py,sha256=gS81Y-9gy_ke17m-2Tt-8mDrawcFNZ15_i0OnT-
 pipecat/services/qwen/llm.py,sha256=X6GOaoKBmQzEI8n-GO2bu4AFdhNFXt6wf7DMMwJ0QFo,1969
 pipecat/services/rime/__init__.py,sha256=lK26ZYuDZS51OybSVPAx6rt710UA1ZBP31wPL1_VeLg,251
 pipecat/services/rime/tts.py,sha256=Iux3gAjiLRN_clC3rxX_OXoA70vAsgMI3gvQI2fmZ_k,20722
+pipecat/services/ringg/__init__.py,sha256=XH_DptHAQ_nUTd4W6WhdMJXIRhxuFI0hrDrWHXxSKyE,233
+pipecat/services/ringg/stt.py,sha256=nO3ymYbzfKIy0krIR7Dk_M7dIp14wkHZmVZrJWY_l_U,13990
 pipecat/services/riva/__init__.py,sha256=rObSsj504O_TMXhPBg_ymqKslZBhovlR-A0aaRZ0O6A,276
 pipecat/services/riva/stt.py,sha256=bAss4dimx8eideaSPmPHM15_rSV3tfXNf13o5n1mfv4,25146
 pipecat/services/riva/tts.py,sha256=idbqx3I2NlWCXtrIFsjEaYapxA3BLIA14ai3aMBh-2w,8158
@@ -418,7 +420,7 @@ pipecat/utils/tracing/service_decorators.py,sha256=fwzxFpi8DJl6BJbK74G0UEB4ccMJg
 pipecat/utils/tracing/setup.py,sha256=7TEgPNpq6M8lww8OQvf0P9FzYc5A30xICGklVA-fua0,2892
 pipecat/utils/tracing/turn_context_provider.py,sha256=ikon3plFOx0XbMrH6DdeHttNpb-U0gzMZIm3bWLc9eI,2485
 pipecat/utils/tracing/turn_trace_observer.py,sha256=dma16SBJpYSOE58YDWy89QzHyQFc_9gQZszKeWixuwc,9725
-dv_pipecat_ai-0.0.85.dev865.dist-info/METADATA,sha256=Hb2X1OfX8oaOJc7tpkfX9m349ozJxunhggPR2tP_Y18,32955
-dv_pipecat_ai-0.0.85.dev865.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dv_pipecat_ai-0.0.85.dev865.dist-info/top_level.txt,sha256=kQzG20CxGf-nSsHmtXHx3hY2-8zHA3jYg8jk0TajqXc,8
-dv_pipecat_ai-0.0.85.dev865.dist-info/RECORD,,
+dv_pipecat_ai-0.0.85.dev866.dist-info/METADATA,sha256=doB6BMiS51CvUgSBtX8wIcHw6hlvs8Ky-VS40YqTaB0,33045
+dv_pipecat_ai-0.0.85.dev866.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+dv_pipecat_ai-0.0.85.dev866.dist-info/top_level.txt,sha256=kQzG20CxGf-nSsHmtXHx3hY2-8zHA3jYg8jk0TajqXc,8
+dv_pipecat_ai-0.0.85.dev866.dist-info/RECORD,,

{dv_pipecat_ai-0.0.85.dev865.dist-info → dv_pipecat_ai-0.0.85.dev866.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

pipecat/services/ringg/__init__.py

@@ -0,0 +1,11 @@
+#
+# Copyright (c) 2024–2025, Daily
+#
+# SPDX-License-Identifier: BSD 2-Clause License
+#
+
+"""Ringg Parrot STT service integration."""
+
+from pipecat.services.ringg.stt import RinggParrotSTTService
+
+__all__ = ["RinggParrotSTTService"]

pipecat/services/ringg/stt.py

@@ -0,0 +1,377 @@
+#
+# Copyright (c) 2024–2025, Daily
+#
+# SPDX-License-Identifier: BSD 2-Clause License
+#
+
+"""Ringg Parrot speech-to-text service implementation.
+
+This service connects to a Ringg Parrot STT WebSocket server for real-time
+transcription. The server provides partial transcripts as audio streams in,
+and final transcripts when explicitly requested via a stop message.
+"""
+
+import asyncio
+import json
+from typing import AsyncGenerator, Optional
+
+from loguru import logger
+from pydantic import BaseModel
+
+from pipecat.frames.frames import (
+    CancelFrame,
+    EndFrame,
+    ErrorFrame,
+    Frame,
+    InterimTranscriptionFrame,
+    StartFrame,
+    StartInterruptionFrame,
+    TranscriptionFrame,
+    UserStoppedSpeakingFrame,
+)
+from enum import Enum
+from pipecat.processors.frame_processor import FrameDirection
+from pipecat.services.stt_service import STTService
+from pipecat.utils.time import time_now_iso8601
+from pipecat.utils.tracing.service_decorators import traced_stt
+
+try:
+    import websockets
+    from websockets.asyncio.client import connect as websocket_connect
+    from websockets.protocol import State
+except ModuleNotFoundError as e:
+    logger.error(f"Exception: {e}")
+    logger.error("In order to use Ringg Parrot STT, you need to `pip install websockets`.")
+    raise Exception(f"Missing module: {e}")
+
+
+STOP_MESSAGE = '{"type": "end"}'
+
+
+class PredictionMethod(str, Enum):
+    """Prediction method for Ringg Parrot STT service."""
+
+    ON_FINAL = "on_final"
+
+
+class RinggParrotInputParams(BaseModel):
+    """Configuration parameters for Ringg Parrot STT service.
+
+    Parameters:
+        encoding: Audio encoding format (default: int16 for PCM signed 16-bit).
+        language: Language for transcription (default: Hindi).
+        punctuate: Whether to add punctuation to transcriptions.
+        partial_chunk_ms: Interval in ms for partial transcription updates.
+    """
+
+    encoding: str = "int16"
+    language: str = "hi"
+    punctuate: bool = False
+    partial_chunk_ms: int = 400
+    prediction_method: PredictionMethod = PredictionMethod.ON_FINAL
+
+
+class RinggParrotSTTService(STTService):
+    """Speech-to-Text service using Ringg Parrot's WebSocket API.
+
+    This service connects to a Ringg Parrot STT WebSocket server for real-time
+    transcription. It follows a VAD-forced endpoint pattern where finalization
+    is triggered when Pipecat's VAD detects the user stopped speaking.
+
+    The server:
+    - Accepts raw PCM audio frames (16-bit signed, 16kHz)
+    - Sends partial transcripts automatically as audio accumulates
+    - Sends final transcript when client sends a stop message
+
+    Example usage::
+
+        stt = RinggParrotSTTService(
+            url="ws://13.234.40.75:7864/v1/audio/stream",
+            language="hi",
+        )
+
+        pipeline = Pipeline([
+            transport.input(),
+            stt,
+            context_aggregator.user(),
+            llm,
+            tts,
+            transport.output(),
+        ])
+    """
+
+    def __init__(
+        self,
+        *,
+        url: str = "ws://13.234.40.75:8888/v1/audio/stream",
+        sample_rate: Optional[int] = 16000,
+        params: Optional[RinggParrotInputParams] = None,
+        **kwargs,
+    ):
+        """Initialize the Ringg Parrot STT service.
+
+        Args:
+            url: WebSocket URL for the Ringg Parrot STT server.
+            sample_rate: Audio sample rate in Hz (default: 16000).
+            params: Additional configuration parameters.
+            **kwargs: Additional arguments passed to the STTService.
+        """
+        super().__init__(sample_rate=sample_rate, **kwargs)
+        params = params or RinggParrotInputParams()
+
+        self._url = url
+        self._params = params
+        self._websocket = None
+        self._receive_task = None
+        self._client_id: Optional[str] = None
+
+        self.set_model_name("ringg-parrot")
+
+    async def start(self, frame: StartFrame):
+        """Start the Ringg Parrot STT websocket connection.
+
+        Connects to the WebSocket server, sends the start configuration,
+        waits for ready confirmation, and starts the receive task.
+
+        Args:
+            frame: The start frame containing initialization parameters.
+        """
+        await super().start(frame)
+        if self._websocket:
+            return
+
+        try:
+            self._websocket = await websocket_connect(self._url)
+
+            if not self._websocket:
+                logger.error(f"Unable to connect to Ringg Parrot STT at {self._url}")
+                await self._call_event_handler("on_connection_error", "Connection failed")
+                return
+
+            # Send the start configuration message
+            start_config = {
+                "type": "start",
+                "sample_rate": self.sample_rate,
+                "encoding": self._params.encoding,
+                "language": self._params.language,
+                "punctuate": self._params.punctuate,
+                "partial_chunk_ms": self._params.partial_chunk_ms,
+                "prediction_method": "on_final",
+            }
+            await self._websocket.send(json.dumps(start_config))
+
+            # Wait for ready response
+            ready_response = await asyncio.wait_for(self._websocket.recv(), timeout=10.0)
+            ready_data = json.loads(ready_response)
+
+            if ready_data.get("type") != "ready":
+                error_msg = f"Unexpected response: {ready_data}"
+                logger.error(f"Ringg Parrot STT: {error_msg}")
+                await self._call_event_handler("on_connection_error", error_msg)
+                await self._cleanup()
+                return
+
+            self._client_id = ready_data.get("client_id")
+            logger.debug(f"Ringg Parrot STT connected, client_id: {self._client_id}")
+
+            # Start the receive task
+            if self._websocket and not self._receive_task:
+                self._receive_task = self.create_task(self._receive_task_handler())
+
+            await self._call_event_handler("on_connected")
+
+        except asyncio.TimeoutError:
+            logger.error("Ringg Parrot STT: Connection timeout waiting for ready response")
+            await self._call_event_handler("on_connection_error", "Connection timeout")
+            await self._cleanup()
+        except Exception as e:
+            logger.error(f"Ringg Parrot STT: Connection error: {e}")
+            await self._call_event_handler("on_connection_error", str(e))
+            await self._cleanup()
+
+    async def _cleanup(self):
+        """Clean up WebSocket connection and tasks."""
+        if self._websocket:
+            try:
+                await self._websocket.close()
+            except Exception:
+                pass
+            self._websocket = None
+
+        if self._receive_task:
+            # Task cannot cancel itself
+            if self._receive_task != asyncio.current_task():
+                await self._receive_task
+            self._receive_task = None
+
+        self._client_id = None
+        logger.debug("Disconnected from Ringg Parrot STT")
+        await self._call_event_handler("on_disconnected")
+
+    async def stop(self, frame: EndFrame):
+        """Stop the Ringg Parrot STT websocket connection.
+
+        Called when the call/pipeline ends. Closes the connection without
+        sending a stop message (final transcripts are triggered by
+        UserStoppedSpeakingFrame during the call).
+
+        Args:
+            frame: The end frame.
+        """
+        await super().stop(frame)
+        await self._cleanup()
+
+    async def cancel(self, frame: CancelFrame):
+        """Cancel the Ringg Parrot STT websocket connection immediately.
+
+        Closes the connection without waiting for final transcript.
+
+        Args:
+            frame: The cancel frame.
+        """
+        await super().cancel(frame)
+        await self._cleanup()
+
+    async def run_stt(self, audio: bytes) -> AsyncGenerator[Frame, None]:
+        """Send audio data to Ringg Parrot STT Service.
+
+        Audio is sent as raw binary bytes to the WebSocket. The server
+        will process and send back transcripts via the receive task.
+
+        Args:
+            audio: Raw audio bytes to transcribe (PCM 16-bit signed).
+
+        Yields:
+            Frame: None (transcription results come via WebSocket callbacks).
+        """
+        await self.start_processing_metrics()
+        if self._websocket and self._websocket.state is State.OPEN:
+            try:
+                await self._websocket.send(audio)
+            except websockets.exceptions.ConnectionClosed:
+                logger.warning("Ringg Parrot STT: WebSocket closed while sending audio")
+            except Exception as e:
+                logger.error(f"Ringg Parrot STT: Error sending audio: {e}")
+        await self.stop_processing_metrics()
+
+        yield None
+
+    @traced_stt
+    async def _handle_transcription(
+        self, transcript: str, is_final: bool, language: Optional[str] = None
+    ):
+        """Handle a transcription result with tracing.
+
+        This method is decorated with @traced_stt to capture STT metrics
+        including transcription latency and text content for observability.
+
+        Args:
+            transcript: The transcribed text.
+            is_final: Whether this is a final (not interim) transcription.
+            language: The detected/configured language.
+        """
+        # Tracing is handled by the @traced_stt decorator
+        # This method exists to provide the hook for metrics collection
+        pass
+
+    async def _send_end_message(self):
+        """Send end message to finalize current transcription."""
+        if self._websocket and self._websocket.state is State.OPEN:
+            try:
+                await self._websocket.send(STOP_MESSAGE)
+                logger.debug("Ringg Parrot STT: Sent end message to finalize transcription")
+            except Exception as e:
+                logger.error(f"Ringg Parrot STT: Error sending end message: {e}")
+
+    async def process_frame(self, frame: Frame, direction: FrameDirection):
+        """Process frames, handling interruption and finalization.
+
+        Handles:
+        - UserStoppedSpeakingFrame: Sends end message to get final transcript
+        - StartInterruptionFrame: Sends end message to finalize any pending
+          transcript before the interruption context switch
+
+        Args:
+            frame: The frame to process.
+            direction: The direction of frame processing.
+        """
+        await super().process_frame(frame, direction)
+
+        if isinstance(frame, UserStoppedSpeakingFrame):
+            # User stopped speaking - finalize to get the transcript
+            await self._send_end_message()
+
+    async def _receive_task_handler(self):
+        """Handle incoming messages from the WebSocket server.
+
+        Processes transcript messages (partial and final), chunk acknowledgments,
+        and error responses. Emits appropriate frames for each message type.
+        """
+        if not self._websocket:
+            return
+
+        try:
+            async for message in self._websocket:
+                try:
+                    content = json.loads(message)
+                except json.JSONDecodeError:
+                    logger.warning(f"Ringg Parrot STT: Invalid JSON: {message}")
+                    continue
+
+                msg_type = content.get("type")
+
+                if msg_type == "transcript":
+                    transcription = content.get("transcription", "")
+                    is_partial = content.get("is_partial", True)
+
+                    if is_partial:
+                        # Partial/interim transcription
+                        if transcription.strip():
+                            await self.push_frame(
+                                InterimTranscriptionFrame(
+                                    text=transcription,
+                                    user_id=self._user_id,
+                                    timestamp=time_now_iso8601(),
+                                )
+                            )
+                    else:
+                        # Final transcription
+                        if transcription.strip():
+                            await self.push_frame(
+                                TranscriptionFrame(
+                                    text=transcription,
+                                    user_id=self._user_id,
+                                    timestamp=time_now_iso8601(),
+                                )
+                            )
+                            await self._handle_transcription(
+                                transcription, is_final=True, language=self._params.language
+                            )
+                            await self.stop_processing_metrics()
+
+                elif msg_type == "chunk":
+                    # Acknowledgment of received audio chunk - no action needed
+                    pass
+
+                elif msg_type == "keepalive":
+                    # Keepalive response - no action needed
+                    pass
+
+                elif msg_type == "error":
+                    error_detail = content.get("detail", "Unknown error")
+                    logger.error(f"Ringg Parrot STT error: {error_detail}")
+                    await self.push_error(ErrorFrame(f"Ringg Parrot STT: {error_detail}"))
+
+                elif msg_type == "ready":
+                    # Already handled in start(), but log if received again
+                    logger.debug("Ringg Parrot STT: Received additional ready message")
+
+                else:
+                    logger.warning(f"Ringg Parrot STT: Unknown message type: {msg_type}")
+
+        except websockets.exceptions.ConnectionClosed:
+            # Expected when closing the connection
+            logger.debug("Ringg Parrot STT: WebSocket connection closed")
+        except Exception as e:
+            logger.error(f"Ringg Parrot STT receive error: {e}")
+            await self.push_error(ErrorFrame(f"Ringg Parrot STT receive error: {e}"))

pipecat/services/stt_service.py

@@ -109,7 +109,6 @@ class STTService(AIService):
 
     async def set_model(self, model: str):
         """Set the speech recognition model.
-
         Args:
             model: The name of the model to use for speech recognition.
         """