vision-agents-plugins-wizper 0.1.8__tar.gz → 0.1.11__tar.gz

{vision_agents_plugins_wizper-0.1.8 → vision_agents_plugins_wizper-0.1.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vision-agents-plugins-wizper
-Version: 0.1.8
+Version: 0.1.11
 Summary: Wizper plugin for Vision Agents
 Project-URL: Documentation, https://visionagents.ai/
 Project-URL: Website, https://visionagents.ai/

{vision_agents_plugins_wizper-0.1.8 → vision_agents_plugins_wizper-0.1.11}/vision_agents/plugins/wizper/stt.py

@@ -24,20 +24,21 @@ Example usage:
 """
 
 import io
+import logging
 import os
 import tempfile
-import time
-import logging
 from pathlib import Path
-from typing import Any, Dict, Optional, List, Tuple, Union, TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from vision_agents.core.edge.types import Participant
+from typing import TYPE_CHECKING, Optional
 import wave
 
 import fal_client
 from getstream.video.rtc.track_util import PcmData
+
 from vision_agents.core import stt
+from vision_agents.core.stt import TranscriptResponse
+
+if TYPE_CHECKING:
+    from vision_agents.core.edge.types import Participant
 
 logger = logging.getLogger(__name__)
 
@@ -58,23 +59,21 @@ class STT(stt.STT):
     def __init__(
         self,
         task: str = "transcribe",
-        target_language: str | None = None,
-        sample_rate: int = 48000,
+        target_language: Optional[str] = None,
         client: Optional[fal_client.AsyncClient] = None,
     ):
         """
-        Initialize FalWizperSTT.
+        Initialize Wizper STT.
 
         Args:
             task: "transcribe" or "translate"
             target_language: Target language code (e.g., "pt" for Portuguese)
-            sample_rate: Sample rate of the audio in Hz.
+            client: Optional fal_client.AsyncClient instance for testing
         """
-        super().__init__(sample_rate=sample_rate)
+        super().__init__(provider_name="wizper")
         self.task = task
+        self.sample_rate = 48000
         self.target_language = target_language
-        self.last_activity_time = time.time()
-        self._is_closed = False
         self._fal_client = client if client is not None else fal_client.AsyncClient()
 
     def _pcm_to_wav_bytes(self, pcm_data: PcmData) -> bytes:
@@ -98,26 +97,25 @@ class STT(stt.STT):
         wav_buffer.seek(0)
         return wav_buffer.read()
 
-    async def _process_audio_impl(
-        self, pcm_data: PcmData, user_metadata: Optional[Union[Dict[str, Any], "Participant"]] = None
-    ) -> Optional[List[Tuple[bool, str, Dict[str, Any]]]]:
+    async def process_audio(
+        self,
+        pcm_data: PcmData,
+        participant: Optional["Participant"] = None,
+    ):
         """
-        Process accumulated speech audio through fal-ai/wizper.
-
-        This method is typically called by VAD (Voice Activity Detection) systems
-        when speech segments are detected.
+        Process audio through fal-ai/wizper for transcription.
 
         Args:
-            speech_audio: Accumulated speech audio as numpy array
-            user: User metadata from the Stream call
+            pcm_data: The PCM audio data to process
+            participant: Optional participant metadata
         """
-        if self._is_closed:
-            logger.debug("connection is closed, ignoring audio")
-            return None
+        if self.closed:
+            logger.warning("Wizper STT is closed, ignoring audio")
+            return
 
         if pcm_data.samples.size == 0:
             logger.debug("No audio data to process")
-            return None
+            return
 
         try:
             logger.debug(
@@ -154,8 +152,9 @@ class STT(stt.STT):
                 if "text" in result:
                     text = result["text"].strip()
                     if text:
+                        response_metadata = TranscriptResponse()
                         self._emit_transcript_event(
-                            text, user_metadata, {"chunks": result.get("chunks", [])}
+                            text, participant, response_metadata
                         )
             finally:
                 # Clean up temporary file
@@ -164,17 +163,15 @@ class STT(stt.STT):
                 except OSError:
                     pass
 
-            # Return None for asynchronous mode - events are emitted when they arrive
-            return None
-
         except Exception as e:
-            logger.error(f"FalWizper processing error: {str(e)}")
-            self._emit_error_event(e, "FalWizper processing")
-            return None
+            logger.error(f"Wizper processing error: {str(e)}")
+            self._emit_error_event(e, "Wizper processing")
 
     async def close(self):
-        """Close the STT service and release any resources."""
-        if self._is_closed:
+        """Close the Wizper STT service and release any resources."""
+        if self.closed:
+            logger.debug("Wizper STT service already closed")
             return
-        self._is_closed = True
-        logger.info("FalWizperSTT closed")
+
+        logger.info("Closing Wizper STT service")
+        await super().close()