videosdk-plugins-deepgram 0.0.1__tar.gz

videosdk_plugins_deepgram-0.0.1/.gitignore

@@ -0,0 +1,10 @@
+myenv/
+venv/
+env/
+__pycache__
+
+.env
+.env.local
+test_env/
+dist/
+.DS_Store

videosdk_plugins_deepgram-0.0.1/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: videosdk-plugins-deepgram
+Version: 0.0.1
+Summary: VideoSDK Agent Framework plugin for Deepgram
+Author: videosdk
+Keywords: ai,audio,deepgram,video,videosdk
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Communications :: Conferencing
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.11
+Requires-Dist: videosdk-agents>=0.0.9
+Description-Content-Type: text/markdown
+
+VideoSDK Deepgram Plugin
+
+Agent Framework plugin for stt services from Deepgram.
+
+## Installation
+
+```bash
+pip install videosdk-plugins-deepgram
+```

videosdk_plugins_deepgram-0.0.1/README.md

@@ -0,0 +1,9 @@
+VideoSDK Deepgram Plugin
+
+Agent Framework plugin for stt services from Deepgram.
+
+## Installation
+
+```bash
+pip install videosdk-plugins-deepgram
+```

videosdk_plugins_deepgram-0.0.1/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "videosdk-plugins-deepgram"
+dynamic = ["version"]
+description = "VideoSDK Agent Framework plugin for Deepgram"
+readme = "README.md"
+requires-python = ">=3.11"
+authors = [{ name = "videosdk"}]
+keywords = ["video", "audio", "ai", "videosdk", "deepgram"]
+classifiers = [
+    "Intended Audience :: Developers",
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Topic :: Communications :: Conferencing",
+    "Topic :: Multimedia :: Sound/Audio",
+    "Topic :: Multimedia :: Video",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "videosdk-agents>=0.0.9"
+]
+
+[tool.hatch.version]
+path = "videosdk/plugins/deepgram/version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["videosdk"]
+
+[tool.hatch.build.targets.sdist]
+include = ["/videosdk"]

videosdk_plugins_deepgram-0.0.1/videosdk/plugins/deepgram/__init__.py

@@ -0,0 +1,3 @@
+from .stt import DeepgramSTT
+
+__all__ = ["DeepgramSTT"]

videosdk_plugins_deepgram-0.0.1/videosdk/plugins/deepgram/stt.py

@@ -0,0 +1,191 @@
+from __future__ import annotations
+
+import asyncio
+import time
+from typing import Any, Optional
+import os
+from urllib.parse import urlencode
+import aiohttp
+from videosdk.agents import STT as BaseSTT, STTResponse, SpeechEventType, SpeechData, global_event_emitter
+
+class DeepgramSTT(BaseSTT):
+    def __init__(
+        self,
+        *,
+        api_key: str | None = None,
+        model: str = "nova-2",
+        language: str = "en-US",
+        interim_results: bool = True,
+        punctuate: bool = True,
+        smart_format: bool = True,
+        sample_rate: int = 48000,
+        endpointing: int = 50,
+        filler_words: bool = True,
+        base_url: str = "wss://api.deepgram.com/v1/listen",
+    ) -> None:
+        super().__init__()
+        
+        self.api_key = api_key or os.getenv("DEEPGRAM_API_KEY")
+        if not self.api_key:
+            raise ValueError("Deepgram API key must be provided either through api_key parameter or DEEPGRAM_API_KEY environment variable")
+        
+        self.model = model
+        self.language = language
+        self.sample_rate = sample_rate
+        self.interim_results = interim_results
+        self.punctuate = punctuate
+        self.smart_format = smart_format
+        self.endpointing = endpointing
+        self.filler_words = filler_words
+        self.base_url = base_url
+        
+        # WebSocket session for streaming
+        self._session: Optional[aiohttp.ClientSession] = None
+        self._ws: Optional[aiohttp.ClientWebSocketResponse] = None
+        self._ws_task: Optional[asyncio.Task] = None
+        
+        self._last_speech_event_time = 0.0
+        self._previous_speech_event_time = 0.0
+        
+    async def process_audio(
+        self,
+        audio_frames: bytes,
+        language: Optional[str] = None,
+        **kwargs: Any
+    ) -> None:
+        """Process audio frames and send to Deepgram's Streaming API"""
+        
+        if not self._ws:
+            await self._connect_ws()
+            # Start listening for responses in background
+            self._ws_task = asyncio.create_task(self._listen_for_responses())
+            
+        try:
+            await self._ws.send_bytes(audio_frames)
+        except Exception as e:
+            print(f"Error in process_audio: {str(e)}")
+            self.emit("error", str(e))
+            if self._ws:
+                await self._ws.close()
+                self._ws = None
+                if self._ws_task:
+                    self._ws_task.cancel()
+                    self._ws_task = None
+
+    async def _listen_for_responses(self) -> None:
+        """Background task to listen for WebSocket responses"""
+        if not self._ws:
+            return
+            
+        try:
+            async for msg in self._ws:
+                if msg.type == aiohttp.WSMsgType.TEXT:
+                    data = msg.json()
+                    responses = self._handle_ws_message(data)
+                    for response in responses:
+                        if self._transcript_callback:
+                            await self._transcript_callback(response)
+                elif msg.type == aiohttp.WSMsgType.ERROR:
+                    self.emit("error", f"WebSocket error: {self._ws.exception()}")
+                    break
+        except Exception as e:
+            self.emit("error", f"Error in WebSocket listener: {str(e)}")
+        finally:
+            if self._ws:
+                await self._ws.close()
+                self._ws = None
+                
+    async def _connect_ws(self) -> None:
+        """Establish WebSocket connection with Deepgram's Streaming API"""
+        
+        if not self._session:
+            self._session = aiohttp.ClientSession()
+            
+        query_params = {
+            "model": self.model,
+            "language": self.language,
+            "interim_results": str(self.interim_results).lower(),
+            "punctuate": str(self.punctuate).lower(),
+            "smart_format": str(self.smart_format).lower(),
+            "encoding": "linear16",
+            "sample_rate": str(self.sample_rate), 
+            "channels": 2,
+            "endpointing": self.endpointing,
+            "filler_words": str(self.filler_words).lower(),
+            "vad_events": "true",
+            "no_delay": "true",
+        }
+        headers = {
+            "Authorization": f"Token {self.api_key}",
+        }
+        
+        ws_url = f"{self.base_url}?{urlencode(query_params)}"
+            
+        try:
+            self._ws = await self._session.ws_connect(ws_url, headers=headers)
+        except Exception as e:
+            print(f"Error connecting to WebSocket: {str(e)}")
+            raise
+        
+    def _handle_ws_message(self, msg: dict) -> list[STTResponse]:
+        """Handle incoming WebSocket messages and generate STT responses"""
+        responses = []
+        try:
+            if msg["type"] == "SpeechStarted":
+                current_time = time.time()
+        
+                if self._last_speech_event_time == 0.0:
+                    self._last_speech_event_time = current_time
+                    return responses
+
+                if current_time - self._last_speech_event_time < 1.0:
+                    global_event_emitter.emit("speech_started")
+
+                self._previous_speech_event_time = self._last_speech_event_time
+                self._last_speech_event_time = current_time
+            
+            if msg["type"] == "Results":
+                channel = msg["channel"]
+                alternatives = channel["alternatives"]
+                
+                if alternatives and len(alternatives) > 0:
+                    alt = alternatives[0]
+                    is_final = msg["is_final"]
+                    if alt["transcript"] == "":
+                        return responses
+                    
+                    response = STTResponse(
+                        event_type=SpeechEventType.FINAL if is_final else SpeechEventType.INTERIM,
+                        data=SpeechData(
+                            text=alt["transcript"],
+                            language=self.language,
+                            confidence=alt.get("confidence", 0.0),
+                            start_time=alt["words"][0]["start"] if alt["words"] else 0.0,
+                            end_time=alt["words"][-1]["end"] if alt["words"] else 0.0,
+                        ),
+                        metadata={"model": self.model}
+                    )
+                    responses.append(response)
+                    
+        except Exception as e:
+            print(f"Error handling WebSocket message: {str(e)}")
+        
+        return responses
+
+    async def aclose(self) -> None:
+        """Cleanup resources"""
+        if self._ws_task:
+            self._ws_task.cancel()
+            try:
+                await self._ws_task
+            except asyncio.CancelledError:
+                pass
+            self._ws_task = None
+            
+        if self._ws:
+            await self._ws.close()
+            self._ws = None
+            
+        if self._session:
+            await self._session.close()
+            self._session = None

videosdk_plugins_deepgram-0.0.1/videosdk/plugins/deepgram/version.py

@@ -0,0 +1 @@
+__version__ = "0.0.1"