dv-pipecat-ai 0.0.74.dev595__tar.gz → 0.0.74.dev613__tar.gz

{dv_pipecat_ai-0.0.74.dev595 → dv_pipecat_ai-0.0.74.dev613}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-ai
-Version: 0.0.74.dev595
+Version: 0.0.74.dev613
 Summary: An open source framework for voice (and multimodal) assistants
 License-Expression: BSD-2-Clause
 Project-URL: Source, https://github.com/pipecat-ai/pipecat

{dv_pipecat_ai-0.0.74.dev595 → dv_pipecat_ai-0.0.74.dev613}/docker-compose.dev.yml

@@ -10,4 +10,4 @@ services:
       - "8765:8765"
     volumes:
       - ./examples/ringg-chatbot:/app
-    command: python server.py
+    command: python server.py

{dv_pipecat_ai-0.0.74.dev595 → dv_pipecat_ai-0.0.74.dev613}/src/dv_pipecat_ai.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-ai
-Version: 0.0.74.dev595
+Version: 0.0.74.dev613
 Summary: An open source framework for voice (and multimodal) assistants
 License-Expression: BSD-2-Clause
 Project-URL: Source, https://github.com/pipecat-ai/pipecat

{dv_pipecat_ai-0.0.74.dev595 → dv_pipecat_ai-0.0.74.dev613}/src/dv_pipecat_ai.egg-info/SOURCES.txt

@@ -188,6 +188,7 @@ src/pipecat/processors/metrics/frame_processor_metrics.py
 src/pipecat/processors/metrics/sentry.py
 src/pipecat/serializers/__init__.py
 src/pipecat/serializers/base_serializer.py
+src/pipecat/serializers/convox.py
 src/pipecat/serializers/exotel.py
 src/pipecat/serializers/genesys.py
 src/pipecat/serializers/livekit.py

{dv_pipecat_ai-0.0.74.dev595 → dv_pipecat_ai-0.0.74.dev613}/src/pipecat/processors/frame_processor.py

@@ -434,31 +434,28 @@ class FrameProcessor(BaseObject):
             self.__input_frame_task = None
 
     async def __input_frame_task_handler(self):
+        """Handle frames from the input queue."""
+        my_queue = self.__input_queue
         while True:
-            frame_tuple = None  # Initialize to None
+            if self.__should_block_frames and self.__input_event:
+                logger.trace(f"{self}: frame processing paused")
+                await self.__input_event.wait()
+                self.__input_event.clear()
+                self.__should_block_frames = False
+                logger.trace(f"{self}: frame processing resumed")
+
+            (frame, direction, callback) = await my_queue.get()
             try:
-                if self.__should_block_frames and self.__input_event:
-                    self.logger.trace(f"{self}: frame processing paused")
-                    await self.__input_event.wait()
-                    self.__input_event.clear()
-                    self.__should_block_frames = False
-                    self.logger.trace(f"{self}: frame processing resumed")
-
-                frame_tuple = await self.__input_queue.get()
-                (frame, direction, callback) = frame_tuple
-
+                # Process the frame.
                 await self.process_frame(frame, direction)
+                # If this frame has an associated callback, call it now.
                 if callback:
                     await callback(self, frame, direction)
-            except asyncio.CancelledError:
-                raise
             except Exception as e:
                 self.logger.exception(f"{self}: error processing frame: {e}")
                 await self.push_error(ErrorFrame(str(e)))
             finally:
-                # Only call task_done() if an item was successfully dequeued.
-                if frame_tuple is not None:
-                    self.__input_queue.task_done()
+                my_queue.task_done()
 
     def __create_push_task(self):
         if not self.__push_frame_task:

dv_pipecat_ai-0.0.74.dev613/src/pipecat/serializers/__init__.py

@@ -0,0 +1,24 @@
+from .base_serializer import FrameSerializer, FrameSerializerType
+from .convox import ConVoxFrameSerializer
+from .exotel import ExotelFrameSerializer
+from .plivo import PlivoFrameSerializer
+from .telnyx import TelnyxFrameSerializer
+from .twilio import TwilioFrameSerializer
+
+__all__ = [
+    "FrameSerializer",
+    "FrameSerializerType", 
+    "ConVoxFrameSerializer",
+    "ExotelFrameSerializer",
+    "PlivoFrameSerializer",
+    "TelnyxFrameSerializer",
+    "TwilioFrameSerializer",
+]
+
+# Optional imports
+try:
+    from .livekit import LiveKitFrameSerializer
+    __all__.append("LiveKitFrameSerializer")
+except (ImportError, Exception):
+    # Catch both ImportError and the Exception raised by livekit.py when module is missing
+    pass

dv_pipecat_ai-0.0.74.dev613/src/pipecat/serializers/convox.py

@@ -0,0 +1,267 @@
+#
+# Copyright (c) 2024–2025, Daily
+#
+# SPDX-License-Identifier: BSD 2-Clause License
+#
+
+import base64
+import json
+from typing import Optional
+
+from loguru import logger
+from pydantic import BaseModel
+
+from pipecat.audio.utils import create_default_resampler
+from pipecat.frames.frames import (
+    AudioRawFrame,
+    EndFrame,
+    Frame,
+    InputAudioRawFrame,
+    InputDTMFFrame,
+    KeypadEntry,
+    StartFrame,
+    StartInterruptionFrame,
+    TransportMessageFrame,
+    TransportMessageUrgentFrame,
+)
+from pipecat.serializers.base_serializer import FrameSerializer, FrameSerializerType
+
+
+class ConVoxFrameSerializer(FrameSerializer):
+    """Serializer for ConVox WebSocket protocol.
+
+    This serializer handles converting between Pipecat frames and ConVox's WebSocket
+    protocol. It supports audio conversion, DTMF events, and real-time communication
+    with ConVox telephony systems.
+
+    ConVox WebSocket protocol typically uses:
+    - PCM audio format at 16kHz sample rate
+    - Base64 encoded audio payloads
+    - JSON message format for control and media events
+    """
+
+    class InputParams(BaseModel):
+        """Configuration parameters for ConVoxFrameSerializer.
+
+        Attributes:
+            convox_sample_rate: Sample rate used by ConVox, defaults to 16000 Hz.
+            sample_rate: Optional override for pipeline input sample rate.
+            auto_hang_up: Whether to automatically terminate call on EndFrame.
+        """
+
+        convox_sample_rate: int = 16000
+        sample_rate: Optional[int] = None
+        auto_hang_up: bool = False
+
+    def __init__(
+        self,
+        stream_id: str,
+        call_id: Optional[str] = None,
+        params: Optional[InputParams] = None,
+    ):
+        """Initialize the ConVoxFrameSerializer.
+
+        Args:
+            stream_id: The ConVox stream identifier.
+            call_id: The associated ConVox call identifier.
+            params: Configuration parameters.
+        """
+        self._stream_id = stream_id
+        self._call_id = call_id
+        self._params = params or ConVoxFrameSerializer.InputParams()
+
+        self._convox_sample_rate = self._params.convox_sample_rate
+        self._sample_rate = 0  # Pipeline input rate
+        self._call_ended = False
+
+        self._resampler = create_default_resampler()
+
+    @property
+    def type(self) -> FrameSerializerType:
+        """Gets the serializer type.
+
+        Returns:
+            The serializer type as TEXT for JSON WebSocket messages.
+        """
+        return FrameSerializerType.TEXT
+
+    async def setup(self, frame: StartFrame):
+        """Sets up the serializer with pipeline configuration.
+
+        Args:
+            frame: The StartFrame containing pipeline configuration.
+        """
+        self._sample_rate = self._params.sample_rate or frame.audio_in_sample_rate
+
+    async def serialize(self, frame: Frame) -> str | bytes | None:
+        """Serializes a Pipecat frame to ConVox WebSocket format.
+
+        Handles conversion of various frame types to ConVox WebSocket messages.
+
+        Args:
+            frame: The Pipecat frame to serialize.
+
+        Returns:
+            Serialized data as JSON string, or None if the frame isn't handled.
+        """
+        if isinstance(frame, StartInterruptionFrame):
+            # Clear/interrupt command for ConVox
+            message = {
+                "event": "clear",
+                "stream_id": self._stream_id,
+                "call_id": self._call_id,
+            }
+            return json.dumps(message)
+
+        elif isinstance(frame, AudioRawFrame):
+            if self._call_ended:
+                logger.debug("🎵 CONVOX SERIALIZE: Skipping audio - call has ended")
+                return None
+                
+            # Convert PCM audio to ConVox format
+            data = frame.audio
+            # logger.info(
+            #     f"🎵 CONVOX SERIALIZE: Processing AudioRawFrame - Original: {len(data)} bytes at {frame.sample_rate}Hz"
+            # )
+
+            # Resample to ConVox sample rate
+            serialized_data = await self._resampler.resample(
+                data, frame.sample_rate, self._convox_sample_rate
+            )
+            # logger.info(
+            #     f"🎵 CONVOX SERIALIZE: Resampled to {self._convox_sample_rate}Hz - {len(serialized_data)} bytes"
+            # )
+
+            # Encode as base64 for transmission
+            payload = base64.b64encode(serialized_data).decode("ascii")
+            logger.info(f"🎵 CONVOX SERIALIZE: Base64 encoded - {len(payload)} characters")
+
+            # ConVox expects play_audio event format according to the documentation
+            import datetime
+
+            timestamp = datetime.datetime.now().isoformat()
+
+            message = {
+                "event": "play_audio",
+                "stream_id": self._stream_id,
+                "call_id": self._call_id,
+                "details": {
+                    "timestamp": timestamp,
+                    "direction": "WSS",
+                    "message": payload,
+                },
+            }
+
+            # logger.info(
+            #     f"🎵 CONVOX SERIALIZE: Sending play_audio event to ConVox - stream_id: {self._stream_id}, call_id: {self._call_id}"
+            # )
+            # logger.debug(f"🎵 CONVOX SERIALIZE: Complete message: {json.dumps(message, indent=2)}")
+
+            return json.dumps(message)
+
+        elif isinstance(frame, (TransportMessageFrame, TransportMessageUrgentFrame)):
+            # Pass through transport messages
+            return json.dumps(frame.message)
+
+        return None
+
+    async def deserialize(self, data: str | bytes) -> Frame | None:
+        """Deserializes ConVox WebSocket data to Pipecat frames.
+
+        Handles conversion of ConVox media events to appropriate Pipecat frames.
+
+        Args:
+            data: The raw WebSocket data from ConVox.
+
+        Returns:
+            A Pipecat frame corresponding to the ConVox event, or None if unhandled.
+        """
+        try:
+            message = json.loads(data)
+        except json.JSONDecodeError:
+            logger.error(f"Invalid JSON received from ConVox: {data}")
+            return None
+
+        event = message.get("event")
+
+        if event == "media":
+            # Handle incoming audio data
+            media = message.get("media", {})
+            payload_base64 = media.get("payload")
+
+            if not payload_base64:
+                logger.warning("🎵 CONVOX DESERIALIZE: No payload in ConVox media message")
+                return None
+
+            try:
+                payload = base64.b64decode(payload_base64)
+                # logger.info(
+                #     f"🎵 CONVOX DESERIALIZE: Received audio from ConVox - {len(payload)} bytes at {self._convox_sample_rate}Hz"
+                # )
+            except Exception as e:
+                logger.error(f"🎵 CONVOX DESERIALIZE: Error decoding ConVox audio payload: {e}")
+                return None
+
+            # Convert from ConVox sample rate to pipeline sample rate
+            deserialized_data = await self._resampler.resample(
+                payload,
+                self._convox_sample_rate,
+                self._sample_rate,
+            )
+            # logger.info(
+            #     f"🎵 CONVOX DESERIALIZE: Resampled to pipeline rate {self._sample_rate}Hz - {len(deserialized_data)} bytes"
+            # )
+
+            audio_frame = InputAudioRawFrame(
+                audio=deserialized_data,
+                num_channels=1,  # ConVox typically uses mono audio
+                sample_rate=self._sample_rate,
+            )
+            # logger.info(
+            #     f"🎵 CONVOX DESERIALIZE: Created InputAudioRawFrame for pipeline processing"
+            # )
+            return audio_frame
+
+        elif event == "dtmf":
+            # Handle DTMF events
+            dtmf_data = message.get("dtmf", {})
+            digit = dtmf_data.get("digit")
+
+            if digit:
+                try:
+                    return InputDTMFFrame(KeypadEntry(digit))
+                except ValueError:
+                    logger.warning(f"Invalid DTMF digit from ConVox: {digit}")
+                    return None
+
+        elif event == "start":
+            # Handle stream start event
+            logger.info(f"ConVox stream started: {message}")
+            return None
+
+        elif event == "stop":
+            # Handle stream stop event
+            logger.info(f"ConVox stream stopped: {message}")
+            return None
+
+        elif event == "error":
+            # Handle error events
+            error_msg = message.get("error", "Unknown error")
+            logger.error(f"ConVox error: {error_msg}")
+            return None
+
+        elif event == "end_call" or event == "call_end":
+            logger.info("ConVox call end event received")
+            self._call_ended = True
+            return EndFrame()
+
+        elif event == "failed":
+            logger.info(f"ConVox failed event received: {message}")
+            self._call_ended = True
+            return EndFrame()
+
+        else:
+            logger.debug(f"Unhandled ConVox event: {event}")
+            return None
+
+        return None

{dv_pipecat_ai-0.0.74.dev595 → dv_pipecat_ai-0.0.74.dev613}/src/pipecat/utils/logger_config.py

@@ -75,6 +75,9 @@ def formatter(record: Dict[str, Any]) -> str:
         record["extra"] = {}
 
     call_id = record["extra"].get("call_id", "unknown")
+    if call_id is None:
+        call_id = "unknown"
+    
     record["extra"]["tags"] = {
         "application": LOGGER_NAME,
         "call_id": call_id,