dv-pipecat-ai 0.0.72.dev651__tar.gz → 0.0.74.dev526__tar.gz

{dv_pipecat_ai-0.0.72.dev651 → dv_pipecat_ai-0.0.74.dev526}/CHANGELOG.md

@@ -5,7 +5,15 @@ All notable changes to **Pipecat** will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## [0.0.73] - 2025-06-26
+
+### Fixed
+
+- Fixed an issue introduced in 0.0.72 that would cause `ElevenLabsTTSService`,
+  `GladiaSTTService`, `NeuphonicTTSService` and `OpenAIRealtimeBetaLLMService`
+  to throw an error.
+
+## [0.0.72] - 2025-06-26
 
 ### Added
 
@@ -86,6 +94,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- Fixed an issue that would cause heartbeat frames to be sent before processors
+  were started.
+
 - Fixed an event loop blocking issue when using `SentryMetrics`.
 
 - Fixed an issue in `FastAPIWebsocketClient` to ensure proper disconnection

{dv_pipecat_ai-0.0.72.dev651 → dv_pipecat_ai-0.0.74.dev526}/CONTRIBUTING.md

@@ -41,36 +41,76 @@ We use Ruff for code linting and formatting. Please ensure your code passes all
 
 We follow Google-style docstrings with these specific conventions:
 
-- Class docstrings should fully document all parameters used in `__init__`
-- We don't require separate docstrings for `__init__` methods when parameters are documented in the class docstring
-- Property methods should have docstrings explaining their purpose and return value
+**Regular Classes:**
 
-Example of correctly documented class:
+- Class docstring describes the class purpose and documents all `__init__` parameters in an `Args:` section
+- No separate `__init__` docstring needed
+- All public methods must have docstrings with `Args:` and `Returns:` sections as appropriate
 
-```python
-class MyClass:
-    """Class description.
+**Dataclasses:**
+
+- Class docstring describes the purpose and documents all fields in a `Parameters:` section
+- No `__init__` docstring (auto-generated)
+
+**Properties:**
+
+- Must have docstrings with `Returns:` section
+
+**Abstract Methods:**
 
-    Additional details about the class.
+- Must have docstrings explaining what subclasses should implement
+
+#### Examples:
+
+```python
+# Regular class
+class MyService(BaseService):
+    """Description of what the service does.
 
     Args:
-        param1: Description of first parameter.
-        param2: Description of second parameter.
+        param1: Description of param1.
+        param2: Description of param2. Defaults to True.
+        **kwargs: Additional arguments passed to parent.
     """
 
-    def __init__(self, param1, param2):
-        # No docstring required here as parameters are documented above
-        self.param1 = param1
-        self.param2 = param2
+    def __init__(self, param1: str, param2: bool = True, **kwargs):
+        # No docstring - parameters documented above
+        super().__init__(**kwargs)
 
     @property
-    def some_property(self) -> str:
-        """Get the formatted property value.
+    def sample_rate(self) -> int:
+        """Get the current sample rate.
 
         Returns:
-            A string representation of the property.
+            The sample rate in Hz.
         """
-        return f"Property: {self.param1}"
+        return self._sample_rate
+
+    async def process_data(self, data: str) -> bool:
+        """Process the provided data.
+
+        Args:
+            data: The data to process.
+
+        Returns:
+            True if processing succeeded.
+        """
+        pass
+
+# Dataclass
+@dataclass
+class ConfigParams:
+    """Configuration parameters for the service.
+
+    Parameters:
+        host: The host address.
+        port: The port number. Defaults to 8080.
+        timeout: Connection timeout in seconds.
+    """
+
+    host: str
+    port: int = 8080
+    timeout: float = 30.0
 ```
 
 # Contributor Covenant Code of Conduct

{dv_pipecat_ai-0.0.72.dev651 → dv_pipecat_ai-0.0.74.dev526}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-ai
-Version: 0.0.72.dev651
+Version: 0.0.74.dev526
 Summary: An open source framework for voice (and multimodal) assistants
 License-Expression: BSD-2-Clause
 Project-URL: Source, https://github.com/pipecat-ai/pipecat
@@ -84,7 +84,7 @@ Requires-Dist: websockets~=13.1; extra == "lmnt"
 Provides-Extra: local
 Requires-Dist: pyaudio~=0.2.14; extra == "local"
 Provides-Extra: mcp
-Requires-Dist: mcp[cli]~=1.6.0; extra == "mcp"
+Requires-Dist: mcp[cli]~=1.9.4; extra == "mcp"
 Provides-Extra: mem0
 Requires-Dist: mem0ai~=0.1.94; extra == "mem0"
 Provides-Extra: mlx-whisper

{dv_pipecat_ai-0.0.72.dev651 → dv_pipecat_ai-0.0.74.dev526}/pyproject.toml

@@ -64,7 +64,7 @@ langchain = [ "langchain~=0.3.20", "langchain-community~=0.3.20", "langchain-ope
 livekit = [ "livekit~=0.22.0", "livekit-api~=0.8.2", "tenacity~=9.0.0" ]
 lmnt = [ "websockets~=13.1" ]
 local = [ "pyaudio~=0.2.14" ]
-mcp = [ "mcp[cli]~=1.6.0" ]
+mcp = [ "mcp[cli]~=1.9.4" ]
 mem0 = [ "mem0ai~=0.1.94" ]
 mlx-whisper = [ "mlx-whisper~=0.4.2" ]
 moondream = [ "einops~=0.8.0", "timm~=1.0.13", "transformers~=4.48.0" ]
@@ -123,9 +123,8 @@ select = [
     "D", # Docstring rules
     "I", # Import rules
 ]
-# We ignore D107 because class docstrings already document __init__ parameters
-# and our Sphinx configuration uses napoleon_include_init_with_doc=True
-ignore = ["D101", "D103", "D102", "D107"]
+# Ignore requirement for __init__ docstrings
+ignore = ["D107"]
 
 [tool.ruff.lint.pydocstyle]
 convention = "google"

{dv_pipecat_ai-0.0.72.dev651 → dv_pipecat_ai-0.0.74.dev526}/src/dv_pipecat_ai.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-ai
-Version: 0.0.72.dev651
+Version: 0.0.74.dev526
 Summary: An open source framework for voice (and multimodal) assistants
 License-Expression: BSD-2-Clause
 Project-URL: Source, https://github.com/pipecat-ai/pipecat
@@ -84,7 +84,7 @@ Requires-Dist: websockets~=13.1; extra == "lmnt"
 Provides-Extra: local
 Requires-Dist: pyaudio~=0.2.14; extra == "local"
 Provides-Extra: mcp
-Requires-Dist: mcp[cli]~=1.6.0; extra == "mcp"
+Requires-Dist: mcp[cli]~=1.9.4; extra == "mcp"
 Provides-Extra: mem0
 Requires-Dist: mem0ai~=0.1.94; extra == "mem0"
 Provides-Extra: mlx-whisper

{dv_pipecat_ai-0.0.72.dev651 → dv_pipecat_ai-0.0.74.dev526}/src/dv_pipecat_ai.egg-info/SOURCES.txt

@@ -351,18 +351,18 @@ src/pipecat/transports/services/tavus.py
 src/pipecat/transports/services/helpers/__init__.py
 src/pipecat/transports/services/helpers/daily_rest.py
 src/pipecat/utils/__init__.py
-src/pipecat/utils/asyncio.py
 src/pipecat/utils/base_object.py
 src/pipecat/utils/logger_config.py
 src/pipecat/utils/network.py
 src/pipecat/utils/string.py
 src/pipecat/utils/time.py
 src/pipecat/utils/utils.py
-src/pipecat/utils/watchdog_async_iterator.py
-src/pipecat/utils/watchdog_event.py
-src/pipecat/utils/watchdog_priority_queue.py
-src/pipecat/utils/watchdog_queue.py
-src/pipecat/utils/watchdog_reseter.py
+src/pipecat/utils/asyncio/__init__.py
+src/pipecat/utils/asyncio/task_manager.py
+src/pipecat/utils/asyncio/watchdog_async_iterator.py
+src/pipecat/utils/asyncio/watchdog_event.py
+src/pipecat/utils/asyncio/watchdog_priority_queue.py
+src/pipecat/utils/asyncio/watchdog_queue.py
 src/pipecat/utils/text/__init__.py
 src/pipecat/utils/text/base_text_aggregator.py
 src/pipecat/utils/text/base_text_filter.py

{dv_pipecat_ai-0.0.72.dev651 → dv_pipecat_ai-0.0.74.dev526}/src/dv_pipecat_ai.egg-info/requires.txt

@@ -101,7 +101,7 @@ torch==2.5.0
 torchaudio==2.5.0
 
 [mcp]
-mcp[cli]~=1.6.0
+mcp[cli]~=1.9.4
 
 [mem0]
 mem0ai~=0.1.94

{dv_pipecat_ai-0.0.72.dev651 → dv_pipecat_ai-0.0.74.dev526}/src/pipecat/pipeline/parallel_pipeline.py

@@ -21,7 +21,7 @@ from pipecat.frames.frames import (
 from pipecat.pipeline.base_pipeline import BasePipeline
 from pipecat.pipeline.pipeline import Pipeline
 from pipecat.processors.frame_processor import FrameDirection, FrameProcessor, FrameProcessorSetup
-from pipecat.utils.watchdog_queue import WatchdogQueue
+from pipecat.utils.asyncio.watchdog_queue import WatchdogQueue
 
 
 class ParallelPipelineSource(FrameProcessor):
@@ -102,8 +102,8 @@ class ParallelPipeline(BasePipeline):
     async def setup(self, setup: FrameProcessorSetup):
         await super().setup(setup)
 
-        self._up_queue = WatchdogQueue(self, watchdog_enabled=setup.watchdog_timers_enabled)
-        self._down_queue = WatchdogQueue(self, watchdog_enabled=setup.watchdog_timers_enabled)
+        self._up_queue = WatchdogQueue(setup.task_manager)
+        self._down_queue = WatchdogQueue(setup.task_manager)
 
         logger.debug(f"Creating {self} pipelines")
         for processors in self._args:

{dv_pipecat_ai-0.0.72.dev651 → dv_pipecat_ai-0.0.74.dev526}/src/pipecat/pipeline/sync_parallel_pipeline.py

@@ -15,7 +15,7 @@ from pipecat.frames.frames import ControlFrame, EndFrame, Frame, SystemFrame
 from pipecat.pipeline.base_pipeline import BasePipeline
 from pipecat.pipeline.pipeline import Pipeline
 from pipecat.processors.frame_processor import FrameDirection, FrameProcessor, FrameProcessorSetup
-from pipecat.utils.watchdog_queue import WatchdogQueue
+from pipecat.utils.asyncio.watchdog_queue import WatchdogQueue
 
 
 @dataclass
@@ -81,8 +81,8 @@ class SyncParallelPipeline(BasePipeline):
     async def setup(self, setup: FrameProcessorSetup):
         await super().setup(setup)
 
-        self._up_queue = WatchdogQueue(self, watchdog_enabled=setup.watchdog_timers_enabled)
-        self._down_queue = WatchdogQueue(self, watchdog_enabled=setup.watchdog_timers_enabled)
+        self._up_queue = WatchdogQueue(setup.task_manager)
+        self._down_queue = WatchdogQueue(setup.task_manager)
 
         logger.debug(f"Creating {self} pipelines")
         for processors in self._args:

{dv_pipecat_ai-0.0.72.dev651 → dv_pipecat_ai-0.0.74.dev526}/src/pipecat/pipeline/task.py

@@ -38,11 +38,15 @@ from pipecat.pipeline.base_pipeline import BasePipeline
 from pipecat.pipeline.base_task import BasePipelineTask, PipelineTaskParams
 from pipecat.pipeline.task_observer import TaskObserver
 from pipecat.processors.frame_processor import FrameDirection, FrameProcessor, FrameProcessorSetup
-from pipecat.utils.asyncio import WATCHDOG_TIMEOUT, BaseTaskManager, TaskManager, TaskManagerParams
+from pipecat.utils.asyncio.task_manager import (
+    WATCHDOG_TIMEOUT,
+    BaseTaskManager,
+    TaskManager,
+    TaskManagerParams,
+)
+from pipecat.utils.asyncio.watchdog_queue import WatchdogQueue
 from pipecat.utils.tracing.setup import is_tracing_available
 from pipecat.utils.tracing.turn_trace_observer import TurnTraceObserver
-from pipecat.utils.watchdog_queue import WatchdogQueue
-from pipecat.utils.watchdog_reseter import WatchdogReseter
 
 HEARTBEAT_SECONDS = 1.0
 HEARTBEAT_MONITOR_SECONDS = HEARTBEAT_SECONDS * 10
@@ -133,7 +137,7 @@ class PipelineTaskSink(FrameProcessor):
         await self._down_queue.put(frame)
 
 
-class PipelineTask(WatchdogReseter, BasePipelineTask):
+class PipelineTask(BasePipelineTask):
     """Manages the execution of a pipeline, handling frame processing and task lifecycle.
 
     It has a couple of event handlers `on_frame_reached_upstream` and
@@ -265,24 +269,28 @@ class PipelineTask(WatchdogReseter, BasePipelineTask):
         self._finished = False
         self._cancelled = False
 
+        # This task maneger will handle all the asyncio tasks created by this
+        # PipelineTask and its frame processors.
+        self._task_manager = task_manager or TaskManager()
+
         # This queue receives frames coming from the pipeline upstream.
-        self._up_queue = WatchdogQueue(self, watchdog_enabled=enable_watchdog_timers)
+        self._up_queue = WatchdogQueue(self._task_manager)
         self._process_up_task: Optional[asyncio.Task] = None
         # This queue receives frames coming from the pipeline downstream.
-        self._down_queue = WatchdogQueue(self, watchdog_enabled=enable_watchdog_timers)
+        self._down_queue = WatchdogQueue(self._task_manager)
         self._process_down_task: Optional[asyncio.Task] = None
         # This queue is the queue used to push frames to the pipeline.
-        self._push_queue = WatchdogQueue(self, watchdog_enabled=enable_watchdog_timers)
+        self._push_queue = WatchdogQueue(self._task_manager)
         self._process_push_task: Optional[asyncio.Task] = None
         # This is the heartbeat queue. When a heartbeat frame is received in the
         # down queue we add it to the heartbeat queue for processing.
-        self._heartbeat_queue = WatchdogQueue(self, watchdog_enabled=enable_watchdog_timers)
+        self._heartbeat_queue = WatchdogQueue(self._task_manager)
         self._heartbeat_push_task: Optional[asyncio.Task] = None
         self._heartbeat_monitor_task: Optional[asyncio.Task] = None
         # This is the idle queue. When frames are received downstream they are
         # put in the queue. If no frame is received the pipeline is considered
         # idle.
-        self._idle_queue = WatchdogQueue(self, watchdog_enabled=enable_watchdog_timers)
+        self._idle_queue = WatchdogQueue(self._task_manager)
         self._idle_monitor_task: Optional[asyncio.Task] = None
         # This event is used to indicate a finalize frame (e.g. EndFrame,
         # StopFrame) has been received in the down queue.
@@ -300,10 +308,6 @@ class PipelineTask(WatchdogReseter, BasePipelineTask):
         self._sink = PipelineTaskSink(self._down_queue)
         pipeline.link(self._sink)
 
-        # This task maneger will handle all the asyncio tasks created by this
-        # PipelineTask and its frame processors.
-        self._task_manager = task_manager or TaskManager()
-
         # The task observer acts as a proxy to the provided observers. This way,
         # we only need to pass a single observer (using the StartFrame) which
         # then just acts as a proxy.
@@ -435,9 +439,6 @@ class PipelineTask(WatchdogReseter, BasePipelineTask):
             for frame in frames:
                 await self.queue_frame(frame)
 
-    def reset_watchdog(self):
-        self._task_manager.reset_watchdog(asyncio.current_task())
-
     async def _cancel(self):
         if not self._cancelled:
             logger.debug(f"Canceling pipeline task {self}")
@@ -462,12 +463,12 @@ class PipelineTask(WatchdogReseter, BasePipelineTask):
             self._process_push_queue(), f"{self}::_process_push_queue"
         )
 
-        await self._observer.start(self._enable_watchdog_timers)
+        await self._observer.start()
 
         return self._process_push_task
 
     def _maybe_start_heartbeat_tasks(self):
-        if self._params.enable_heartbeats:
+        if self._params.enable_heartbeats and self._heartbeat_push_task is None:
             self._heartbeat_push_task = self._task_manager.create_task(
                 self._heartbeat_push_handler(), f"{self}::_heartbeat_push_handler"
             )
@@ -565,7 +566,6 @@ class PipelineTask(WatchdogReseter, BasePipelineTask):
         """
         self._clock.start()
 
-        self._maybe_start_heartbeat_tasks()
         self._maybe_start_idle_task()
 
         start_frame = StartFrame(
@@ -647,6 +647,10 @@ class PipelineTask(WatchdogReseter, BasePipelineTask):
 
             if isinstance(frame, StartFrame):
                 await self._call_event_handler("on_pipeline_started", frame)
+
+                # Start heartbeat tasks now that StartFrame has been processed
+                # by all processors in the pipeline
+                self._maybe_start_heartbeat_tasks()
             elif isinstance(frame, EndFrame):
                 await self._call_event_handler("on_pipeline_ended", frame)
                 self._pipeline_end_event.set()

{dv_pipecat_ai-0.0.72.dev651 → dv_pipecat_ai-0.0.74.dev526}/src/pipecat/pipeline/task_observer.py

@@ -11,9 +11,8 @@ from typing import Dict, List, Optional
 from attr import dataclass
 
 from pipecat.observers.base_observer import BaseObserver, FramePushed
-from pipecat.utils.asyncio import BaseTaskManager
-from pipecat.utils.watchdog_queue import WatchdogQueue
-from pipecat.utils.watchdog_reseter import WatchdogReseter
+from pipecat.utils.asyncio.task_manager import BaseTaskManager
+from pipecat.utils.asyncio.watchdog_queue import WatchdogQueue
 
 
 @dataclass
@@ -28,7 +27,7 @@ class Proxy:
     observer: BaseObserver
 
 
-class TaskObserver(WatchdogReseter, BaseObserver):
+class TaskObserver(BaseObserver):
     """This is a pipeline frame observer that is meant to be used as a proxy to
     the user provided observers. That is, this is the observer that should be
     passed to the frame processors. Then, every time a frame is pushed this
@@ -54,7 +53,6 @@ class TaskObserver(WatchdogReseter, BaseObserver):
         self._proxies: Optional[Dict[BaseObserver, Proxy]] = (
             None  # Becomes a dict after start() is called
         )
-        self._watchdog_timers_enabled = False
 
     def add_observer(self, observer: BaseObserver):
         # Add the observer to the list.
@@ -79,9 +77,8 @@ class TaskObserver(WatchdogReseter, BaseObserver):
         if observer in self._observers:
             self._observers.remove(observer)
 
-    async def start(self, watchdog_timers_enabled: bool = False):
+    async def start(self):
         """Starts all proxy observer tasks."""
-        self._watchdog_timers_enabled = watchdog_timers_enabled
         self._proxies = self._create_proxies(self._observers)
 
     async def stop(self):
@@ -96,14 +93,11 @@ class TaskObserver(WatchdogReseter, BaseObserver):
         for proxy in self._proxies.values():
             await proxy.queue.put(data)
 
-    def reset_watchdog(self):
-        self._task_manager.reset_watchdog(asyncio.current_task())
-
     def _started(self) -> bool:
         return self._proxies is not None
 
     def _create_proxy(self, observer: BaseObserver) -> Proxy:
-        queue = WatchdogQueue(self, watchdog_enabled=self._watchdog_timers_enabled)
+        queue = WatchdogQueue(self._task_manager)
         task = self._task_manager.create_task(
             self._proxy_task_handler(queue, observer),
             f"TaskObserver::{observer}::_proxy_task_handler",

{dv_pipecat_ai-0.0.72.dev651 → dv_pipecat_ai-0.0.74.dev526}/src/pipecat/processors/consumer_processor.py

@@ -10,7 +10,7 @@ from typing import Awaitable, Callable, Optional
 from pipecat.frames.frames import CancelFrame, EndFrame, Frame, StartFrame
 from pipecat.processors.frame_processor import FrameDirection, FrameProcessor
 from pipecat.processors.producer_processor import ProducerProcessor, identity_transformer
-from pipecat.utils.watchdog_queue import WatchdogQueue
+from pipecat.utils.asyncio.watchdog_queue import WatchdogQueue
 
 
 class ConsumerProcessor(FrameProcessor):
@@ -32,7 +32,7 @@ class ConsumerProcessor(FrameProcessor):
         super().__init__(**kwargs)
         self._transformer = transformer
         self._direction = direction
-        self._queue: WatchdogQueue = producer.add_consumer(self)
+        self._producer = producer
         self._consumer_task: Optional[asyncio.Task] = None
 
     async def process_frame(self, frame: Frame, direction: FrameDirection):
@@ -49,6 +49,7 @@ class ConsumerProcessor(FrameProcessor):
 
     async def _start(self, _: StartFrame):
         if not self._consumer_task:
+            self._queue: WatchdogQueue = self._producer.add_consumer()
             self._consumer_task = self.create_task(self._consumer_task_handler())
 
     async def _stop(self, _: EndFrame):

{dv_pipecat_ai-0.0.72.dev651 → dv_pipecat_ai-0.0.74.dev526}/src/pipecat/processors/frame_processor.py

@@ -29,11 +29,10 @@ from pipecat.frames.frames import (
 from pipecat.metrics.metrics import LLMTokenUsage, MetricsData
 from pipecat.observers.base_observer import BaseObserver, FramePushed
 from pipecat.processors.metrics.frame_processor_metrics import FrameProcessorMetrics
-from pipecat.utils.asyncio import BaseTaskManager
+from pipecat.utils.asyncio.task_manager import BaseTaskManager
+from pipecat.utils.asyncio.watchdog_event import WatchdogEvent
+from pipecat.utils.asyncio.watchdog_queue import WatchdogQueue
 from pipecat.utils.base_object import BaseObject
-from pipecat.utils.watchdog_event import WatchdogEvent
-from pipecat.utils.watchdog_queue import WatchdogQueue
-from pipecat.utils.watchdog_reseter import WatchdogReseter
 
 
 class FrameDirection(Enum):
@@ -49,7 +48,7 @@ class FrameProcessorSetup:
     watchdog_timers_enabled: bool = False
 
 
-class FrameProcessor(WatchdogReseter, BaseObject):
+class FrameProcessor(BaseObject):
     def __init__(
         self,
         *,
@@ -89,7 +88,6 @@ class FrameProcessor(WatchdogReseter, BaseObject):
         self._enable_usage_metrics = False
         self._report_only_initial_ttfb = False
         self._interruption_strategies: List[BaseInterruptionStrategy] = []
-        self._watchdog_timers_enabled = False
 
         # Indicates whether we have received the StartFrame.
         self.__started = False
@@ -148,8 +146,10 @@ class FrameProcessor(WatchdogReseter, BaseObject):
         return self._interruption_strategies
 
     @property
-    def watchdog_timers_enabled(self):
-        return self._watchdog_timers_enabled
+    def task_manager(self) -> BaseTaskManager:
+        if not self._task_manager:
+            raise Exception(f"{self} TaskManager is still not initialized.")
+        return self._task_manager
 
     def can_generate_metrics(self) -> bool:
         return False
@@ -206,7 +206,7 @@ class FrameProcessor(WatchdogReseter, BaseObject):
             name = f"{self}::{name}"
         else:
             name = f"{self}::{coroutine.cr_code.co_name}"
-        return self.get_task_manager().create_task(
+        return self.task_manager.create_task(
             coroutine,
             name,
             enable_watchdog_logging=(
@@ -215,7 +215,7 @@ class FrameProcessor(WatchdogReseter, BaseObject):
                 else self._enable_watchdog_logging
             ),
             enable_watchdog_timers=(
-                enable_watchdog_timers if enable_watchdog_timers else self.watchdog_timers_enabled
+                enable_watchdog_timers if enable_watchdog_timers else self._enable_watchdog_timers
             ),
             watchdog_timeout=(
                 watchdog_timeout_secs if watchdog_timeout_secs else self._watchdog_timeout_secs
@@ -223,13 +223,13 @@ class FrameProcessor(WatchdogReseter, BaseObject):
         )
 
     async def cancel_task(self, task: asyncio.Task, timeout: Optional[float] = None):
-        await self.get_task_manager().cancel_task(task, timeout)
+        await self.task_manager.cancel_task(task, timeout)
 
     async def wait_for_task(self, task: asyncio.Task, timeout: Optional[float] = None):
-        await self.get_task_manager().wait_for_task(task, timeout)
+        await self.task_manager.wait_for_task(task, timeout)
 
     def reset_watchdog(self):
-        self.get_task_manager().reset_watchdog(asyncio.current_task())
+        self.task_manager.task_reset_watchdog()
 
     async def setup(self, setup: FrameProcessorSetup):
         self._clock = setup.clock
@@ -241,7 +241,7 @@ class FrameProcessor(WatchdogReseter, BaseObject):
             else setup.watchdog_timers_enabled
         )
         if self._metrics is not None:
-            await self._metrics.setup(self._task_manager, self._watchdog_timers_enabled)
+            await self._metrics.setup(self._task_manager)
 
     async def cleanup(self):
         await super().cleanup()
@@ -256,7 +256,7 @@ class FrameProcessor(WatchdogReseter, BaseObject):
         self.logger.debug(f"Linking {self} -> {self._next}")
 
     def get_event_loop(self) -> asyncio.AbstractEventLoop:
-        return self.get_task_manager().get_event_loop()
+        return self.task_manager.get_event_loop()
 
     def set_parent(self, parent: "FrameProcessor"):
         self._parent = parent
@@ -269,11 +269,6 @@ class FrameProcessor(WatchdogReseter, BaseObject):
             raise Exception(f"{self} Clock is still not initialized.")
         return self._clock
 
-    def get_task_manager(self) -> BaseTaskManager:
-        if not self._task_manager:
-            raise Exception(f"{self} TaskManager is still not initialized.")
-        return self._task_manager
-
     async def queue_frame(
         self,
         frame: Frame,
@@ -424,11 +419,9 @@ class FrameProcessor(WatchdogReseter, BaseObject):
         if not self.__input_frame_task:
             self.__should_block_frames = False
             if not self.__input_event:
-                self.__input_event = WatchdogEvent(
-                    self, watchdog_enabled=self.watchdog_timers_enabled
-                )
+                self.__input_event = WatchdogEvent(self.task_manager)
             self.__input_event.clear()
-            self.__input_queue = WatchdogQueue(self, watchdog_enabled=self.watchdog_timers_enabled)
+            self.__input_queue = WatchdogQueue(self.task_manager)
             self.__input_frame_task = self.create_task(self.__input_frame_task_handler())
 
     async def __cancel_input_task(self):
@@ -460,7 +453,7 @@ class FrameProcessor(WatchdogReseter, BaseObject):
 
     def __create_push_task(self):
         if not self.__push_frame_task:
-            self.__push_queue = WatchdogQueue(self, watchdog_enabled=self.watchdog_timers_enabled)
+            self.__push_queue = WatchdogQueue(self.task_manager)
             self.__push_frame_task = self.create_task(self.__push_frame_task_handler())
 
     async def __cancel_push_task(self):

{dv_pipecat_ai-0.0.72.dev651 → dv_pipecat_ai-0.0.74.dev526}/src/pipecat/processors/frameworks/rtvi.py

@@ -67,8 +67,8 @@ from pipecat.services.llm_service import (
 from pipecat.transports.base_input import BaseInputTransport
 from pipecat.transports.base_output import BaseOutputTransport
 from pipecat.transports.base_transport import BaseTransport
+from pipecat.utils.asyncio.watchdog_queue import WatchdogQueue
 from pipecat.utils.string import match_endofsentence
-from pipecat.utils.watchdog_queue import WatchdogQueue
 
 RTVI_PROTOCOL_VERSION = "0.3.0"
 
@@ -755,10 +755,10 @@ class RTVIProcessor(FrameProcessor):
 
     async def _start(self, frame: StartFrame):
         if not self._action_task:
-            self._action_queue = WatchdogQueue(self, watchdog_enabled=self.watchdog_timers_enabled)
+            self._action_queue = WatchdogQueue(self.task_manager)
             self._action_task = self.create_task(self._action_task_handler())
         if not self._message_task:
-            self._message_queue = WatchdogQueue(self, watchdog_enabled=self.watchdog_timers_enabled)
+            self._message_queue = WatchdogQueue(self.task_manager)
             self._message_task = self.create_task(self._message_task_handler())
         await self._call_event_handler("on_bot_started")
 

{dv_pipecat_ai-0.0.72.dev651 → dv_pipecat_ai-0.0.74.dev526}/src/pipecat/processors/metrics/frame_processor_metrics.py

@@ -18,7 +18,7 @@ from pipecat.metrics.metrics import (
     TTFBMetricsData,
     TTSUsageMetricsData,
 )
-from pipecat.utils.asyncio import TaskManager
+from pipecat.utils.asyncio.task_manager import BaseTaskManager
 from pipecat.utils.base_object import BaseObject
 
 
@@ -32,14 +32,14 @@ class FrameProcessorMetrics(BaseObject):
         self._should_report_ttfb = True
         self._logger = logger
 
-    async def setup(self, task_manager: TaskManager, watchdog_timers_enabled: bool = False):
+    async def setup(self, task_manager: BaseTaskManager):
         self._task_manager = task_manager
 
     async def cleanup(self):
         await super().cleanup()
 
     @property
-    def task_manager(self) -> TaskManager:
+    def task_manager(self) -> BaseTaskManager:
         return self._task_manager
 
     @property