dv-pipecat-ai 0.0.82.dev815__py3-none-any.whl → 0.0.82.dev857__py3-none-any.whl

pipecat/processors/aggregators/openai_llm_context.py

@@ -15,7 +15,7 @@ import copy
 import io
 import json
 from dataclasses import dataclass
-from typing import Any, List, Optional
+from typing import Any, Dict, List, Optional
 
 from openai._types import NOT_GIVEN, NotGiven
 from openai.types.chat import (
@@ -183,13 +183,13 @@ class OpenAILLMContext:
         """
         return json.dumps(self._messages, cls=CustomEncoder, ensure_ascii=False, indent=2)
 
-    def get_messages_for_logging(self) -> str:
+    def get_messages_for_logging(self) -> List[Dict[str, Any]]:
         """Get sanitized messages suitable for logging.
 
         Removes or truncates sensitive data like image content for safe logging.
 
         Returns:
-            JSON string with sanitized message content for logging.
+            List of messages in a format ready for logging.
         """
         msgs = []
         for message in self.messages:

pipecat/processors/dtmf_aggregator.py

@@ -8,7 +8,6 @@ from pipecat.frames.frames import (
     InputDTMFFrame,
     StartInterruptionFrame,
     StartUserIdleProcessorFrame,
-    StopInterruptionFrame,
     StopUserIdleProcessorFrame,
     TranscriptionFrame,
     UserStartedSpeakingFrame,
@@ -132,7 +131,6 @@ class DTMFAggregator(FrameProcessor):
             aggregated_frame.metadata["push_aggregation"] = True
             await self.push_frame(StartInterruptionFrame())
             await self.push_frame(aggregated_frame, direction)
-            await self.push_frame(StopInterruptionFrame())
             self._aggregation = ""
         elif raise_timeout and self._stopped_idle_processor:
             transcript_frame = TranscriptionFrame(

pipecat/processors/filters/stt_mute_filter.py

@@ -27,7 +27,6 @@ from pipecat.frames.frames import (
     InterimTranscriptionFrame,
     StartFrame,
     StartInterruptionFrame,
-    StopInterruptionFrame,
     STTMuteFrame,
     TranscriptionFrame,
     UserStartedSpeakingFrame,
@@ -213,7 +212,6 @@ class STTMuteFilter(FrameProcessor):
         # Conditionally include InputAudioRawFrame in suppression tuple based on voicemail_detection_enabled
         suppression_types = (
             StartInterruptionFrame,
-            StopInterruptionFrame,
             VADUserStartedSpeakingFrame,
             VADUserStoppedSpeakingFrame,
             UserStartedSpeakingFrame,

pipecat/processors/frame_processor.py

@@ -31,7 +31,6 @@ from pipecat.frames.frames import (
     FrameProcessorResumeUrgentFrame,
     StartFrame,
     StartInterruptionFrame,
-    StopInterruptionFrame,
     SystemFrame,
 )
 from pipecat.metrics.metrics import LLMTokenUsage, MetricsData
@@ -127,6 +126,11 @@ class FrameProcessorQueue(asyncio.PriorityQueue):
         return item
 
 
+# Timeout in seconds for cancelling the input frame processing task.
+# This prevents hanging if a library swallows asyncio.CancelledError.
+INPUT_TASK_CANCEL_TIMEOUT_SECS = 3
+
+
 class FrameProcessor(BaseObject):
     """Base class for all frame processors in the pipeline.
 
@@ -446,7 +450,7 @@ class FrameProcessor(BaseObject):
 
         .. deprecated:: 0.0.81
             This function is deprecated, use `await task` or
-            `await asyncio.wait_for(task, timeout) instead.
+            `await asyncio.wait_for(task, timeout)` instead.
 
         Args:
             task: The task to wait for.
@@ -454,12 +458,14 @@ class FrameProcessor(BaseObject):
         """
         import warnings
 
-        warnings.warn(
-            "`FrameProcessor.wait_for_task()` is deprecated. "
-            "Use `await task` or `await asyncio.wait_for(task, timeout)` instead.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
+        with warnings.catch_warnings():
+            warnings.simplefilter("always")
+            warnings.warn(
+                "`FrameProcessor.wait_for_task()` is deprecated. "
+                "Use `await task` or `await asyncio.wait_for(task, timeout)` instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
 
         if timeout:
             await asyncio.wait_for(task, timeout)
@@ -587,8 +593,6 @@ class FrameProcessor(BaseObject):
         elif isinstance(frame, StartInterruptionFrame):
             await self._start_interruption()
             await self.stop_all_metrics()
-        elif isinstance(frame, StopInterruptionFrame):
-            self._should_report_ttfb = True
         elif isinstance(frame, CancelFrame):
             await self.__cancel(frame)
         elif isinstance(frame, (FrameProcessorPauseFrame, FrameProcessorPauseUrgentFrame)):
@@ -753,7 +757,10 @@ class FrameProcessor(BaseObject):
     async def __cancel_input_task(self):
         """Cancel the frame input processing task."""
         if self.__input_frame_task:
-            await self.cancel_task(self.__input_frame_task)
+            # Apply a timeout as a safeguard: if a library swallows asyncio.CancelledError,
+            # the task would otherwise never be cancelled. With a timeout, we can detect this
+            # situation and surface it in the logs instead of hanging indefinitely.
+            await self.cancel_task(self.__input_frame_task, INPUT_TASK_CANCEL_TIMEOUT_SECS)
             self.__input_frame_task = None
 
     def __create_process_task(self):

pipecat/processors/frameworks/rtvi.py

@@ -42,6 +42,7 @@ from pipecat.frames.frames import (
     FunctionCallResultFrame,
     InputAudioRawFrame,
     InterimTranscriptionFrame,
+    LLMContextFrame,
     LLMFullResponseEndFrame,
     LLMFullResponseStartFrame,
     LLMMessagesAppendFrame,
@@ -916,7 +917,10 @@ class RTVIObserver(BaseObserver):
             and self._params.user_transcription_enabled
         ):
             await self._handle_user_transcriptions(frame)
-        elif isinstance(frame, OpenAILLMContextFrame) and self._params.user_llm_enabled:
+        elif (
+            isinstance(frame, (OpenAILLMContextFrame, LLMContextFrame))
+            and self._params.user_llm_enabled
+        ):
             await self._handle_context(frame)
         elif isinstance(frame, LLMFullResponseStartFrame) and self._params.bot_llm_enabled:
             await self.push_transport_message_urgent(RTVIBotLLMStartedMessage())
@@ -1017,16 +1021,20 @@ class RTVIObserver(BaseObserver):
         if message:
             await self.push_transport_message_urgent(message)
 
-    async def _handle_context(self, frame: OpenAILLMContextFrame):
+    async def _handle_context(self, frame: OpenAILLMContextFrame | LLMContextFrame):
         """Process LLM context frames to extract user messages for the RTVI client."""
         try:
-            messages = frame.context.messages
+            if isinstance(frame, OpenAILLMContextFrame):
+                messages = frame.context.messages
+            else:
+                messages = frame.context.get_messages()
             if not messages:
                 return
 
             message = messages[-1]
 
             # Handle Google LLM format (protobuf objects with attributes)
+            # Note: not possible if frame is a universal LLMContextFrame
             if hasattr(message, "role") and message.role == "user" and hasattr(message, "parts"):
                 text = "".join(part.text for part in message.parts if hasattr(part, "text"))
                 if text:
@@ -1116,7 +1124,9 @@ class RTVIProcessor(FrameProcessor):
         self._bot_ready = False
         self._client_ready = False
         self._client_ready_id = ""
-        self._client_version = []
+        # Default to 0.3.0 which is the last version before actually having a
+        # "client-version".
+        self._client_version = [0, 3, 0]
         self._errors_enabled = True
 
         self._registered_actions: Dict[str, RTVIAction] = {}
@@ -1423,16 +1433,13 @@ class RTVIProcessor(FrameProcessor):
 
     async def _handle_client_ready(self, request_id: str, data: RTVIClientReadyData | None):
         """Handle the client-ready message from the client."""
-        version = data.version if data else "unknown"
+        version = data.version if data else None
         logger.debug(f"Received client-ready: version {version}")
-        if version == "unknown":
-            self._client_version = [0, 3, 0]  # Default to 0.3.0 if unknown
-        else:
+        if version:
             try:
                 self._client_version = [int(v) for v in version.split(".")]
             except ValueError:
                 logger.warning(f"Invalid client version format: {version}")
-                self._client_version = [0, 3, 0]
         about = data.about if data else {"library": "unknown"}
         logger.debug(f"Client Details: {about}")
         if self._input_transport:
@@ -1615,7 +1622,7 @@ class RTVIProcessor(FrameProcessor):
     async def _send_bot_ready(self):
         """Send the bot-ready message to the client."""
         config = None
-        if self._client_version[0] < 1:
+        if self._client_version and self._client_version[0] < 1:
             config = self._config.config
         message = RTVIBotReady(
             id=self._client_ready_id,

pipecat/processors/metrics/sentry.py

@@ -6,6 +6,8 @@
 
 """Sentry integration for frame processor metrics."""
 
+import asyncio
+
 from loguru import logger
 
 from pipecat.utils.asyncio.task_manager import BaseTaskManager

pipecat/runner/daily.py

@@ -10,6 +10,10 @@ This module provides helper functions for creating and configuring Daily rooms
 and authentication tokens. It automatically creates temporary rooms for
 development or uses existing rooms specified via environment variables.
 
+Functions:
+
+- configure(): Create a standard or SIP-enabled Daily room, returning a DailyRoomConfig object.
+
 Environment variables:
 
 - DAILY_API_KEY - Daily API key for room/token creation (required)
@@ -22,39 +26,95 @@ Example::
     from pipecat.runner.daily import configure
 
     async with aiohttp.ClientSession() as session:
+        # Standard room
         room_url, token = await configure(session)
-        # Use room_url and token with DailyTransport
+
+        # SIP-enabled room for phone calls
+        config = await configure(session, sip_caller_phone="+15551234567")
+        # config contains: room_url, token, sip_endpoint
 """
 
 import os
 import time
 import uuid
-from typing import Tuple
+from typing import Dict, List, Optional
 
 import aiohttp
+from loguru import logger
+from pydantic import BaseModel
 
-from pipecat.transports.services.helpers.daily_rest import (
+from pipecat.transports.daily.utils import (
     DailyRESTHelper,
     DailyRoomParams,
     DailyRoomProperties,
+    DailyRoomSipParams,
 )
 
 
-async def configure(aiohttp_session: aiohttp.ClientSession) -> Tuple[str, str]:
-    """Configure Daily room URL and token from environment variables.
+class DailyRoomConfig(BaseModel):
+    """Configuration returned when creating a Daily room.
+
+    Parameters:
+        room_url: The Daily room URL for joining the meeting.
+        token: Authentication token for the bot to join the room.
+        sip_endpoint: SIP endpoint URI for phone connections (None for standard rooms).
+    """
+
+    room_url: str
+    token: str
+    sip_endpoint: Optional[str] = None
+
+    def __iter__(self):
+        """Enable tuple unpacking for backward compatibility.
+
+        Allows: room_url, token = await configure(session)
+        """
+        yield self.room_url
+        yield self.token
+
+
+async def configure(
+    aiohttp_session: aiohttp.ClientSession,
+    *,
+    room_exp_duration: Optional[float] = 2.0,
+    token_exp_duration: Optional[float] = 2.0,
+    sip_caller_phone: Optional[str] = None,
+    sip_enable_video: Optional[bool] = False,
+    sip_num_endpoints: Optional[int] = 1,
+    sip_codecs: Optional[Dict[str, List[str]]] = None,
+) -> DailyRoomConfig:
+    """Configure Daily room URL and token with optional SIP capabilities.
 
     This function will either:
-    1. Use an existing room URL from DAILY_SAMPLE_ROOM_URL environment variable
+    1. Use an existing room URL from DAILY_SAMPLE_ROOM_URL environment variable (standard mode only)
     2. Create a new temporary room automatically if no URL is provided
 
     Args:
         aiohttp_session: HTTP session for making API requests.
+        room_exp_duration: Room expiration time in hours.
+        token_exp_duration: Token expiration time in hours.
+        sip_caller_phone: Phone number or identifier for SIP display name.
+            When provided, enables SIP functionality and returns SipRoomConfig.
+        sip_enable_video: Whether video is enabled for SIP.
+        sip_num_endpoints: Number of allowed SIP endpoints.
+        sip_codecs: Codecs to support for audio and video. If None, uses Daily defaults.
+            Example: {"audio": ["OPUS"], "video": ["H264"]}
 
     Returns:
-        Tuple containing the room URL and authentication token.
+        DailyRoomConfig: Object with room_url, token, and optional sip_endpoint.
+        Supports tuple unpacking for backward compatibility: room_url, token = await configure(session)
 
     Raises:
         Exception: If DAILY_API_KEY is not provided in environment variables.
+
+    Examples::
+
+        # Standard room
+        room_url, token = await configure(session)
+
+        # SIP-enabled room
+        sip_config = await configure(session, sip_caller_phone="+15551234567")
+        print(f"SIP endpoint: {sip_config.sip_endpoint}")
     """
     # Check for required API key
     api_key = os.getenv("DAILY_API_KEY")
@@ -64,8 +124,8 @@ async def configure(aiohttp_session: aiohttp.ClientSession) -> Tuple[str, str]:
             "Get your API key from https://dashboard.daily.co/developers"
         )
 
-    # Check for existing room URL
-    existing_room_url = os.getenv("DAILY_SAMPLE_ROOM_URL")
+    # Determine if SIP mode is enabled
+    sip_enabled = sip_caller_phone is not None
 
     daily_rest_helper = DailyRESTHelper(
         daily_api_key=api_key,
@@ -73,36 +133,75 @@ async def configure(aiohttp_session: aiohttp.ClientSession) -> Tuple[str, str]:
         aiohttp_session=aiohttp_session,
     )
 
-    if existing_room_url:
-        # Use existing room
-        print(f"Using existing Daily room: {existing_room_url}")
+    # Check for existing room URL (only in standard mode)
+    existing_room_url = os.getenv("DAILY_SAMPLE_ROOM_URL")
+    if existing_room_url and not sip_enabled:
+        # Use existing room (standard mode only)
+        logger.info(f"Using existing Daily room: {existing_room_url}")
         room_url = existing_room_url
-    else:
-        # Create a new temporary room
-        room_name = f"pipecat-{uuid.uuid4().hex[:8]}"
-        print(f"Creating new Daily room: {room_name}")
-
-        # Calculate expiration time: current time + 2 hours
-        expiration_time = time.time() + (2 * 60 * 60)  # 2 hours from now
-
-        # Create room properties with absolute timestamp
-        room_properties = DailyRoomProperties(
-            exp=expiration_time,  # Absolute Unix timestamp
-            eject_at_room_exp=True,
+
+        # Create token and return standard format
+        expiry_time: float = token_exp_duration * 60 * 60
+        token = await daily_rest_helper.get_token(room_url, expiry_time)
+        return DailyRoomConfig(room_url=room_url, token=token)
+
+    # Create a new room
+    room_prefix = "pipecat-sip" if sip_enabled else "pipecat"
+    room_name = f"{room_prefix}-{uuid.uuid4().hex[:8]}"
+    logger.info(f"Creating new Daily room: {room_name}")
+
+    # Calculate expiration time
+    expiration_time = time.time() + (room_exp_duration * 60 * 60)
+
+    # Create room properties
+    room_properties = DailyRoomProperties(
+        exp=expiration_time,
+        eject_at_room_exp=True,
+    )
+
+    # Add SIP configuration if enabled
+    if sip_enabled:
+        sip_params = DailyRoomSipParams(
+            display_name=sip_caller_phone,
+            video=sip_enable_video,
+            sip_mode="dial-in",
+            num_endpoints=sip_num_endpoints,
+            codecs=sip_codecs,
         )
+        room_properties.sip = sip_params
+        room_properties.enable_dialout = True  # Enable outbound calls if needed
+        room_properties.start_video_off = not sip_enable_video  # Voice-only by default
 
-        # Create room parameters
-        room_params = DailyRoomParams(name=room_name, properties=room_properties)
+    # Create room parameters
+    room_params = DailyRoomParams(name=room_name, properties=room_properties)
 
+    try:
         room_response = await daily_rest_helper.create_room(room_params)
         room_url = room_response.url
-        print(f"Created Daily room: {room_url}")
+        logger.info(f"Created Daily room: {room_url}")
+
+        # Create meeting token
+        token_expiry_seconds = token_exp_duration * 60 * 60
+        token = await daily_rest_helper.get_token(room_url, token_expiry_seconds)
 
-    # Create a meeting token for the room with an expiration 2 hours in the future
-    expiry_time: float = 2 * 60 * 60
-    token = await daily_rest_helper.get_token(room_url, expiry_time)
+        if sip_enabled:
+            # Return SIP configuration object
+            sip_endpoint = room_response.config.sip_endpoint
+            logger.info(f"SIP endpoint: {sip_endpoint}")
 
-    return (room_url, token)
+            return DailyRoomConfig(
+                room_url=room_url,
+                token=token,
+                sip_endpoint=sip_endpoint,
+            )
+        else:
+            # Return standard configuration
+            return DailyRoomConfig(room_url=room_url, token=token)
+
+    except Exception as e:
+        error_msg = f"Error creating Daily room: {e}"
+        logger.error(error_msg)
+        raise
 
 
 # Keep this for backwards compatibility, but mark as deprecated
@@ -122,11 +221,13 @@ async def configure_with_args(aiohttp_session: aiohttp.ClientSession, parser=Non
     """
     import warnings
 
-    warnings.warn(
-        "configure_with_args is deprecated. Use configure() instead.",
-        DeprecationWarning,
-        stacklevel=2,
-    )
+    with warnings.catch_warnings():
+        warnings.simplefilter("always")
+        warnings.warn(
+            "configure_with_args is deprecated. Use configure() instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
 
     room_url, token = await configure(aiohttp_session)
     return (room_url, token, None)

pipecat/runner/run.py

@@ -182,7 +182,7 @@ def _setup_webrtc_routes(app: FastAPI, esp32_mode: bool = False, host: str = "lo
     try:
         from pipecat_ai_small_webrtc_prebuilt.frontend import SmallWebRTCPrebuiltUI
 
-        from pipecat.transports.network.webrtc_connection import SmallWebRTCConnection
+        from pipecat.transports.smallwebrtc.connection import SmallWebRTCConnection
     except ImportError as e:
         logger.error(f"WebRTC transport dependencies not installed: {e}")
         return

pipecat/runner/utils.py

@@ -203,7 +203,7 @@ def get_transport_client_id(transport: BaseTransport, client: Any) -> str:
     """
     # Import conditionally to avoid dependency issues
     try:
-        from pipecat.transports.network.small_webrtc import SmallWebRTCTransport
+        from pipecat.transports.smallwebrtc.transport import SmallWebRTCTransport
 
         if isinstance(transport, SmallWebRTCTransport):
             return client.pc_id
@@ -211,7 +211,7 @@ def get_transport_client_id(transport: BaseTransport, client: Any) -> str:
         pass
 
     try:
-        from pipecat.transports.services.daily import DailyTransport
+        from pipecat.transports.daily.transport import DailyTransport
 
         if isinstance(transport, DailyTransport):
             return client["id"]
@@ -233,7 +233,7 @@ async def maybe_capture_participant_camera(
         framerate: Video capture framerate. Defaults to 0 (auto).
     """
     try:
-        from pipecat.transports.services.daily import DailyTransport
+        from pipecat.transports.daily.transport import DailyTransport
 
         if isinstance(transport, DailyTransport):
             await transport.capture_participant_video(
@@ -254,7 +254,7 @@ async def maybe_capture_participant_screen(
         framerate: Video capture framerate. Defaults to 0 (auto).
     """
     try:
-        from pipecat.transports.services.daily import DailyTransport
+        from pipecat.transports.daily.transport import DailyTransport
 
         if isinstance(transport, DailyTransport):
             await transport.capture_participant_video(
@@ -359,7 +359,7 @@ async def _create_telephony_transport(
     Returns:
         Configured FastAPIWebsocketTransport ready for telephony use.
     """
-    from pipecat.transports.network.fastapi_websocket import FastAPIWebsocketTransport
+    from pipecat.transports.websocket.fastapi import FastAPIWebsocketTransport
 
     if params is None:
         raise ValueError(
@@ -482,7 +482,7 @@ async def create_transport(
     if isinstance(runner_args, DailyRunnerArguments):
         params = _get_transport_params("daily", transport_params)
 
-        from pipecat.transports.services.daily import DailyTransport
+        from pipecat.transports.daily.transport import DailyTransport
 
         return DailyTransport(
             runner_args.room_url,
@@ -494,7 +494,7 @@ async def create_transport(
     elif isinstance(runner_args, SmallWebRTCRunnerArguments):
         params = _get_transport_params("webrtc", transport_params)
 
-        from pipecat.transports.network.small_webrtc import SmallWebRTCTransport
+        from pipecat.transports.smallwebrtc.transport import SmallWebRTCTransport
 
         return SmallWebRTCTransport(
             params=params,

pipecat/serializers/asterisk.py

@@ -33,7 +33,7 @@ class AsteriskFrameSerializer(FrameSerializer):
 
         # What the ADAPTER/Asterisk is sending/expecting on the wire:
         # "pcmu" -> μ-law @ 8k; "pcm16" -> signed 16-bit @ 8k
-        telephony_encoding: Literal["pcmu", "pcm16"] = "pcmu"
+        telephony_encoding: Literal["pcmu", "pcma", "pcm16"] = "pcmu"
         telephony_sample_rate: int = 8000
         sample_rate: Optional[int] = None  # pipeline input rate
         auto_hang_up: bool = False  # no-op here; adapter handles hangup
@@ -45,6 +45,7 @@ class AsteriskFrameSerializer(FrameSerializer):
         self._sample_rate = 0
         self._in_resampler = create_stream_resampler()
         self._out_resampler = create_stream_resampler()
+        self._hangup_sent = False
 
     @property
     def type(self) -> FrameSerializerType:
@@ -80,6 +81,19 @@ class AsteriskFrameSerializer(FrameSerializer):
                         "payload": payload,
                     }
                 )
+            elif self._params.telephony_encoding == "pcma":
+                al = await pcm_to_alaw(pcm, frame.sample_rate, self._tel_rate, self._out_resampler)
+                if not al:
+                    return None
+                payload = base64.b64encode(al).decode("utf-8")
+                return json.dumps(
+                    {
+                        "event": "media",
+                        "encoding": "pcma",
+                        "sampleRate": self._tel_rate,
+                        "payload": payload,
+                    }
+                )
             else:  # "pcm16"
                 # resample to 8k if needed, but data stays PCM16 bytes
                 pcm8 = await self._out_resampler.resample(pcm, frame.sample_rate, self._tel_rate)
@@ -105,14 +119,16 @@ class AsteriskFrameSerializer(FrameSerializer):
         except Exception:
             return None
         if msg.get("event") == "media":
-            enc = msg.get("encoding")
             sr = int(msg.get("sampleRate", self._tel_rate))
             raw = base64.b64decode(msg.get("payload", ""))
             if not raw:
                 return None
-            if enc == "pcmu":
+            # Use our configured telephony_encoding instead of trusting the message
+            if self._params.telephony_encoding == "pcmu":
                 pcm = await ulaw_to_pcm(raw, sr, self._sample_rate, self._in_resampler)
-            elif enc == "pcm16":
+            elif self._params.telephony_encoding == "pcma":
+                pcm = await alaw_to_pcm(raw, sr, self._sample_rate, self._in_resampler)
+            elif self._params.telephony_encoding == "pcm16":
                 # resample if pipeline rate != 8k
                 pcm = await self._in_resampler.resample(raw, sr, self._sample_rate)
             else:

pipecat/serializers/exotel.py

@@ -13,13 +13,13 @@ from typing import Optional
 from loguru import logger
 from pydantic import BaseModel
 
+from pipecat.audio.dtmf.types import KeypadEntry
 from pipecat.audio.utils import create_stream_resampler
 from pipecat.frames.frames import (
     AudioRawFrame,
     Frame,
     InputAudioRawFrame,
     InputDTMFFrame,
-    KeypadEntry,
     StartFrame,
     StartInterruptionFrame,
     TransportMessageFrame,

pipecat/serializers/plivo.py

@@ -13,6 +13,7 @@ from typing import Optional
 from loguru import logger
 from pydantic import BaseModel
 
+from pipecat.audio.dtmf.types import KeypadEntry
 from pipecat.audio.utils import create_stream_resampler, pcm_to_ulaw, ulaw_to_pcm
 from pipecat.frames.frames import (
     AudioRawFrame,
@@ -21,7 +22,6 @@ from pipecat.frames.frames import (
     Frame,
     InputAudioRawFrame,
     InputDTMFFrame,
-    KeypadEntry,
     StartFrame,
     StartInterruptionFrame,
     TransportMessageFrame,

pipecat/serializers/telnyx.py

@@ -14,6 +14,7 @@ import aiohttp
 from loguru import logger
 from pydantic import BaseModel
 
+from pipecat.audio.dtmf.types import KeypadEntry
 from pipecat.audio.utils import (
     alaw_to_pcm,
     create_stream_resampler,
@@ -28,7 +29,6 @@ from pipecat.frames.frames import (
     Frame,
     InputAudioRawFrame,
     InputDTMFFrame,
-    KeypadEntry,
     StartFrame,
     StartInterruptionFrame,
 )

pipecat/serializers/twilio.py

@@ -13,6 +13,7 @@ from typing import Optional
 from loguru import logger
 from pydantic import BaseModel
 
+from pipecat.audio.dtmf.types import KeypadEntry
 from pipecat.audio.utils import create_stream_resampler, pcm_to_ulaw, ulaw_to_pcm
 from pipecat.frames.frames import (
     AudioRawFrame,
@@ -21,7 +22,6 @@ from pipecat.frames.frames import (
     Frame,
     InputAudioRawFrame,
     InputDTMFFrame,
-    KeypadEntry,
     StartFrame,
     StartInterruptionFrame,
     TransportMessageFrame,

pipecat/services/__init__.py

@@ -11,11 +11,11 @@ _warned_modules = set()
 
 
 def _warn_deprecated_access(globals: Dict[str, Any], attr, old: str, new: str):
-    import warnings
-
     # Only warn once per old->new module pair
     module_key = (old, new)
     if module_key not in _warned_modules:
+        import warnings
+
         with warnings.catch_warnings():
             warnings.simplefilter("always")
             warnings.warn(