dv-pipecat-ai 0.0.74.dev770__py3-none-any.whl → 0.0.82.dev776__py3-none-any.whl

pipecat/services/google/stt.py

@@ -4,12 +4,18 @@
 # SPDX-License-Identifier: BSD 2-Clause License
 #
 
+"""Google Cloud Speech-to-Text V2 service implementation for Pipecat.
+
+This module provides a Google Cloud Speech-to-Text V2 service with streaming
+support, enabling real-time speech recognition with features like automatic
+punctuation, voice activity detection, and multi-language support.
+"""
+
 import asyncio
 import json
 import os
 import time
 
-from pipecat.utils.asyncio.watchdog_async_iterator import WatchdogAsyncIterator
 from pipecat.utils.tracing.service_decorators import traced_stt
 
 # Suppress gRPC fork warnings
@@ -353,9 +359,15 @@ class GoogleSTTService(STTService):
 
     Provides real-time speech recognition using Google Cloud's Speech-to-Text V2 API
     with streaming support. Handles audio transcription and optional voice activity detection.
+    Implements automatic stream reconnection to handle Google's 4-minute streaming limit.
 
-    Attributes:
+    Parameters:
         InputParams: Configuration parameters for the STT service.
+        STREAMING_LIMIT: Google Cloud's streaming limit in milliseconds (4 minutes).
+
+    Raises:
+        ValueError: If neither credentials nor credentials_path is provided.
+        ValueError: If project ID is not found in credentials.
     """
 
     # Google Cloud's STT service has a connection time limit of 5 minutes per stream.
@@ -367,7 +379,7 @@ class GoogleSTTService(STTService):
     class InputParams(BaseModel):
         """Configuration parameters for Google Speech-to-Text.
 
-        Attributes:
+        Parameters:
             languages: Single language or list of recognition languages. First language is primary.
             model: Speech recognition model to use.
             use_separate_recognition_per_channel: Process each audio channel separately.
@@ -396,13 +408,25 @@ class GoogleSTTService(STTService):
         @field_validator("languages", mode="before")
         @classmethod
         def validate_languages(cls, v) -> List[Language]:
+            """Ensure languages is always a list.
+
+            Args:
+                v: Single Language enum or list of Language enums.
+
+            Returns:
+                List[Language]: List of configured languages.
+            """
             if isinstance(v, Language):
                 return [v]
             return v
 
         @property
         def language_list(self) -> List[Language]:
-            """Get languages as a guaranteed list."""
+            """Get languages as a guaranteed list.
+
+            Returns:
+                List[Language]: List of configured languages.
+            """
             assert isinstance(self.languages, list)
             return self.languages
 
@@ -425,10 +449,6 @@ class GoogleSTTService(STTService):
             sample_rate: Audio sample rate in Hertz.
             params: Configuration parameters for the service.
             **kwargs: Additional arguments passed to STTService.
-
-        Raises:
-            ValueError: If neither credentials nor credentials_path is provided.
-            ValueError: If project ID is not found in credentials.
         """
         super().__init__(sample_rate=sample_rate, **kwargs)
 
@@ -501,6 +521,11 @@ class GoogleSTTService(STTService):
         }
 
     def can_generate_metrics(self) -> bool:
+        """Check if the service can generate metrics.
+
+        Returns:
+            bool: True, as this service supports metrics generation.
+        """
         return True
 
     def language_to_service_language(self, language: Language | List[Language]) -> str | List[str]:
@@ -548,7 +573,11 @@ class GoogleSTTService(STTService):
         await self._reconnect_if_needed()
 
     async def set_model(self, model: str):
-        """Update the service's recognition model."""
+        """Update the service's recognition model.
+
+        Args:
+            model: The new recognition model to use.
+        """
         logger.debug(f"Switching STT model to: {model}")
         await super().set_model(model)
         self._settings["model"] = model
@@ -556,14 +585,29 @@ class GoogleSTTService(STTService):
         await self._reconnect_if_needed()
 
     async def start(self, frame: StartFrame):
+        """Start the STT service and establish connection.
+
+        Args:
+            frame: The start frame triggering the service start.
+        """
         await super().start(frame)
         await self._connect()
 
     async def stop(self, frame: EndFrame):
+        """Stop the STT service and clean up resources.
+
+        Args:
+            frame: The end frame triggering the service stop.
+        """
         await super().stop(frame)
         await self._disconnect()
 
     async def cancel(self, frame: CancelFrame):
+        """Cancel the STT service and clean up resources.
+
+        Args:
+            frame: The cancel frame triggering the service cancellation.
+        """
         await super().cancel(frame)
         await self._disconnect()
 
@@ -585,7 +629,7 @@ class GoogleSTTService(STTService):
         """Update service options dynamically.
 
         Args:
-            languages: New list of recongition languages.
+            languages: New list of recognition languages.
             model: New recognition model.
             enable_automatic_punctuation: Enable/disable automatic punctuation.
             enable_spoken_punctuation: Enable/disable spoken punctuation.
@@ -736,7 +780,6 @@ class GoogleSTTService(STTService):
                     if self._request_queue.empty():
                         # wait for 10ms in case we don't have audio
                         await asyncio.sleep(0.01)
-                        self.reset_watchdog()
                         continue
 
                     # Start bi-directional streaming
@@ -767,7 +810,14 @@ class GoogleSTTService(STTService):
             await self.push_frame(ErrorFrame(str(e)))
 
     async def run_stt(self, audio: bytes) -> AsyncGenerator[Frame, None]:
-        """Process an audio chunk for STT transcription."""
+        """Process an audio chunk for STT transcription.
+
+        Args:
+            audio: Raw audio bytes to transcribe.
+
+        Yields:
+            Frame: None (actual transcription frames are pushed via internal processing).
+        """
         if self._streaming_task:
             # Queue the audio data
             await self.start_ttfb_metrics()
@@ -784,9 +834,7 @@ class GoogleSTTService(STTService):
     async def _process_responses(self, streaming_recognize):
         """Process streaming recognition responses."""
         try:
-            async for response in WatchdogAsyncIterator(
-                streaming_recognize, manager=self.task_manager
-            ):
+            async for response in streaming_recognize:
                 # Check streaming limit
                 if (int(time.time() * 1000) - self._stream_start_time) > self.STREAMING_LIMIT:
                     logger.debug("Stream timeout reached in response processing")
@@ -810,7 +858,7 @@ class GoogleSTTService(STTService):
                         await self.push_frame(
                             TranscriptionFrame(
                                 transcript,
-                                "",
+                                self._user_id,
                                 time_now_iso8601(),
                                 primary_language,
                                 result=result,
@@ -828,7 +876,7 @@ class GoogleSTTService(STTService):
                         await self.push_frame(
                             InterimTranscriptionFrame(
                                 transcript,
-                                "",
+                                self._user_id,
                                 time_now_iso8601(),
                                 primary_language,
                                 result=result,

pipecat/services/google/test-google-chirp.py

@@ -0,0 +1,45 @@
+import asyncio
+import os
+
+from pipecat.frames.frames import TTSAudioRawFrame
+from pipecat.services.google.tts import GoogleTTSService
+
+
+async def test_chirp_tts():
+    # Get credentials from environment variable
+    credentials_path = (
+        "/Users/kalicharanvemuru/Documents/Code/pipecat/examples/ringg-chatbot/creds.json"
+    )
+
+    if not credentials_path or not os.path.exists(credentials_path):
+        raise ValueError(
+            "Please set GOOGLE_APPLICATION_CREDENTIALS environment variable to your service account key file"
+        )
+
+    # Initialize the TTS service with Chirp voice
+    tts = GoogleTTSService(
+        credentials_path=credentials_path,
+        voice_id="en-US-Chirp3-HD-Charon",  # Using Chirp3 HD Charon voice
+        sample_rate=24000,
+    )
+
+    # Test text
+    test_text = "Hello, this is a test of the Google TTS service with Chirp voice."
+
+    print(f"Testing TTS with text: {test_text}")
+
+    # Generate speech
+    try:
+        async for frame in tts.run_tts(test_text):
+            if isinstance(frame, TTSAudioRawFrame):
+                print(f"Received audio chunk of size: {len(frame.audio)} bytes")
+            else:
+                print(f"Received frame: {frame.__class__.__name__}")
+
+        print("TTS generation completed successfully!")
+    except Exception as e:
+        print(f"Error during TTS generation: {str(e)}")
+
+
+if __name__ == "__main__":
+    asyncio.run(test_chirp_tts())