vision-agents-plugins-deepgram 0.2.7__py3-none-any.whl

.gitignore

@@ -0,0 +1,90 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.cursor/*
+# Distribution / packaging
+.Python
+build/
+dist/
+downloads/
+develop-eggs/
+eggs/
+.eggs/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+pip-wheel-metadata/
+MANIFEST
+*.egg-info/
+*.egg
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+coverage.xml
+nosetests.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Type checker / lint caches
+.mypy_cache/
+.dmypy.json
+dmypy.json
+.pytype/
+.pyre/
+.ruff_cache/
+
+# Environments
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+.env
+.env.local
+.env.*.local
+.env.bak
+pyvenv.cfg
+.python-version
+
+# Editors / IDEs
+.vscode/
+.idea/
+
+# Jupyter Notebook
+.ipynb_checkpoints/
+
+# OS / Misc
+.DS_Store
+*.log
+
+# Tooling & repo-specific
+pyrightconfig.json
+shell.nix
+bin/*
+lib/*
+stream-py/
+
+# Artifacts / assets
+*.pt
+*.kef
+*.onnx
+profile.html
+
+/opencode.json

PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: vision-agents-plugins-deepgram
+Version: 0.2.7
+Summary: Deepgram STT and TTS integration for Vision Agents
+Project-URL: Documentation, https://visionagents.ai/
+Project-URL: Website, https://visionagents.ai/
+Project-URL: Source, https://github.com/GetStream/Vision-Agents
+License-Expression: MIT
+Keywords: AI,STT,TTS,agents,deepgram,speech-to-text,text-to-speech,transcription,voice agents
+Requires-Python: >=3.10
+Requires-Dist: deepgram-sdk>=5.3.0
+Requires-Dist: numpy<2.3,>=2.2.6
+Requires-Dist: vision-agents
+Description-Content-Type: text/markdown
+
+# Deepgram Plugin
+
+Speech-to-Text (STT) and Text-to-Speech (TTS) plugins for Vision Agents using the Deepgram API.
+
+## Installation
+
+```bash
+uv add vision-agents-plugins-deepgram
+```
+
+## Speech-to-Text (STT)
+
+High-quality speech recognition using Deepgram's Flux model with built-in turn detection.
+
+```python
+from vision_agents.plugins import deepgram
+
+stt = deepgram.STT(
+    model="flux-general-en",  # Default model
+    eager_turn_detection=True,  # Enable eager end-of-turn detection
+)
+```
+
+### STT Docs
+
+- https://developers.deepgram.com/docs/flux/quickstart
+- https://github.com/deepgram/deepgram-python-sdk/blob/main/examples/listen/v2/connect/async.py
+
+## Text-to-Speech (TTS)
+
+Low-latency text-to-speech using Deepgram's Aura model via WebSocket streaming.
+
+```python
+from vision_agents.plugins import deepgram
+
+tts = deepgram.TTS(
+    model="aura-2-thalia-en",  # Default voice
+    sample_rate=16000,  # Audio sample rate
+)
+```
+
+### Available Voices
+
+Deepgram offers various Aura voice models:
+- `aura-2-thalia-en` - Default female voice
+- `aura-2-orion-en` - Male voice
+- See [TTS Models](https://developers.deepgram.com/docs/tts-models) for all options
+
+### TTS Docs
+
+- https://developers.deepgram.com/docs/tts-websocket
+- https://developers.deepgram.com/docs/streaming-text-to-speech
+
+## Environment Variables
+
+Set `DEEPGRAM_API_KEY` in your environment or pass `api_key` to the constructor.
+
+## Example
+
+See the [example](./example/) directory for a complete working example using both STT and TTS.

README.md

@@ -0,0 +1,60 @@
+# Deepgram Plugin
+
+Speech-to-Text (STT) and Text-to-Speech (TTS) plugins for Vision Agents using the Deepgram API.
+
+## Installation
+
+```bash
+uv add vision-agents-plugins-deepgram
+```
+
+## Speech-to-Text (STT)
+
+High-quality speech recognition using Deepgram's Flux model with built-in turn detection.
+
+```python
+from vision_agents.plugins import deepgram
+
+stt = deepgram.STT(
+    model="flux-general-en",  # Default model
+    eager_turn_detection=True,  # Enable eager end-of-turn detection
+)
+```
+
+### STT Docs
+
+- https://developers.deepgram.com/docs/flux/quickstart
+- https://github.com/deepgram/deepgram-python-sdk/blob/main/examples/listen/v2/connect/async.py
+
+## Text-to-Speech (TTS)
+
+Low-latency text-to-speech using Deepgram's Aura model via WebSocket streaming.
+
+```python
+from vision_agents.plugins import deepgram
+
+tts = deepgram.TTS(
+    model="aura-2-thalia-en",  # Default voice
+    sample_rate=16000,  # Audio sample rate
+)
+```
+
+### Available Voices
+
+Deepgram offers various Aura voice models:
+- `aura-2-thalia-en` - Default female voice
+- `aura-2-orion-en` - Male voice
+- See [TTS Models](https://developers.deepgram.com/docs/tts-models) for all options
+
+### TTS Docs
+
+- https://developers.deepgram.com/docs/tts-websocket
+- https://developers.deepgram.com/docs/streaming-text-to-speech
+
+## Environment Variables
+
+Set `DEEPGRAM_API_KEY` in your environment or pass `api_key` to the constructor.
+
+## Example
+
+See the [example](./example/) directory for a complete working example using both STT and TTS.

pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "vision-agents-plugins-deepgram"
+dynamic = ["version"]
+description = "Deepgram STT and TTS integration for Vision Agents"
+readme = "README.md"
+keywords = ["deepgram", "STT", "TTS", "speech-to-text", "text-to-speech", "transcription", "AI", "voice agents", "agents"]
+requires-python = ">=3.10"
+license = "MIT"
+dependencies = [
+    "vision-agents",
+    "deepgram-sdk>=5.3.0",
+    "numpy>=2.2.6,<2.3",
+]
+
+[project.urls]
+Documentation = "https://visionagents.ai/"
+Website = "https://visionagents.ai/"
+Source = "https://github.com/GetStream/Vision-Agents"
+
+[tool.hatch.version]
+source = "vcs"
+raw-options = { root = "..", search_parent_directories = true, fallback_version = "0.0.0" }
+
+[tool.hatch.build.targets.wheel]
+packages = [".", "vision_agents"]
+
+[tool.hatch.build.targets.sdist]
+include = ["/vision_agents"]
+
+[tool.uv.sources]
+vision-agents = { workspace = true }
+
+[dependency-groups]
+dev = [
+    "pytest>=8.4.1",
+    "pytest-asyncio>=1.0.0",
+    "soundfile>=0.13.1",
+    "torchvision>=0.20.0",
+    "scipy>=1.15.3,<1.16",
+]

vision_agents/plugins/deepgram/__init__.py

@@ -0,0 +1,7 @@
+from .deepgram_stt import STT
+from .tts import TTS
+
+# Re-export under the new namespace for convenience
+__path__ = __import__("pkgutil").extend_path(__path__, __name__)
+
+__all__ = ["STT", "TTS"]

vision_agents/plugins/deepgram/deepgram_stt.py

@@ -0,0 +1,288 @@
+import asyncio
+import logging
+import os
+from typing import Optional, Any
+
+from deepgram import AsyncDeepgramClient
+from deepgram.core import EventType
+from deepgram.extensions.types.sockets import ListenV2ControlMessage
+from deepgram.listen.v2.socket_client import AsyncV2SocketClient
+from getstream.video.rtc.track_util import PcmData
+
+from vision_agents.core import stt
+from vision_agents.core.stt import TranscriptResponse
+from vision_agents.core.edge.types import Participant
+
+logger = logging.getLogger(__name__)
+
+
+class STT(stt.STT):
+    """
+    Deepgram Speech-to-Text implementation using Flux model.
+
+    - https://developers.deepgram.com/docs/flux/quickstart
+    - https://github.com/deepgram/deepgram-python-sdk/blob/main/examples/listen/v2/connect/async.py
+    - https://github.com/deepgram/deepgram-python-sdk/tree/main
+    - https://github.com/deepgram-devs/deepgram-demos-flux-streaming-transcription/blob/main/main.py
+
+    Deepgram flux runs turn detection internally. So running turn detection in front of this is optional/not needed
+
+    - eot_threshold controls turn end sensitivity
+    - eager_eot_threshold controls eager turn ending (so you can already prepare the LLM response)
+    """
+
+    turn_detection: bool = True  # we support turn detection with deepgram
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        model: str = "flux-general-en",
+        language: Optional[str] = None,
+        eager_turn_detection: bool = False,
+        eot_threshold: Optional[float] = None,
+        eager_eot_threshold: Optional[float] = None,
+        client: Optional[AsyncDeepgramClient] = None,
+    ):
+        """
+        Initialize Deepgram STT.
+
+        Args:
+            api_key: Deepgram API key. If not provided, will use DEEPGRAM_API_KEY env var.
+            model: Model to use for transcription. Defaults to "flux-general-en".
+            language: Language code (e.g., "en", "es"). If not provided, auto-detection is used.
+            eot_threshold: End-of-turn threshold for determining when a turn is complete.
+            eager_eot_threshold: Eager end-of-turn threshold for faster turn detection.
+            client: Optional pre-configured AsyncDeepgramClient instance.
+        """
+        super().__init__(provider_name="deepgram")
+
+        if not api_key:
+            api_key = os.environ.get("DEEPGRAM_API_KEY")
+
+        if client is not None:
+            self.client = client
+        else:
+            # Initialize AsyncDeepgramClient with api_key as named parameter
+            if api_key:
+                self.client = AsyncDeepgramClient(api_key=api_key)
+            else:
+                self.client = AsyncDeepgramClient()
+
+        self.model = model
+        self.language = language
+        self.eot_threshold = eot_threshold
+        self.eager_turn_detection = eager_turn_detection
+        if self.eager_turn_detection and eager_eot_threshold is None:
+            eager_eot_threshold = 0.5
+        self.eager_eot_threshold = eager_eot_threshold
+        self._current_participant: Optional[Participant] = None
+        self.connection: Optional[AsyncV2SocketClient] = None
+        self._connection_ready = asyncio.Event()
+        self._connection_context: Optional[Any] = None
+        self._listen_task: Optional[asyncio.Task[Any]] = None
+
+    async def process_audio(
+        self,
+        pcm_data: PcmData,
+        participant: Optional[Participant] = None,
+    ):
+        """
+        Process audio data through Deepgram for transcription.
+
+        This method sends audio to the existing WebSocket connection. The connection
+        is started automatically on first use. Audio is automatically resampled to 16kHz.
+
+        Args:
+            pcm_data: The PCM audio data to process.
+            participant: Optional participant metadata (currently not used in streaming mode).
+        """
+        if self.closed:
+            logger.warning("Deepgram STT is closed, ignoring audio")
+            return
+
+        # Wait for connection to be ready
+        await self._connection_ready.wait()
+
+        # Double-check connection is still ready (could have closed while waiting)
+        if not self._connection_ready.is_set():
+            logger.warning("Deepgram connection closed while processing audio")
+            return
+
+        # Resample to 16kHz mono (recommended by Deepgram)
+        resampled_pcm = pcm_data.resample(16_000, 1)
+
+        # Convert int16 samples to bytes
+        audio_bytes = resampled_pcm.samples.tobytes()
+
+        self._current_participant = participant
+
+        if self.connection is not None:
+            await self.connection.send_media(audio_bytes)
+
+    async def start(self):
+        """
+        Start the Deepgram WebSocket connection and begin listening for transcripts.
+        """
+        if self.connection is not None:
+            logger.warning("Deepgram connection already started")
+            return
+
+        # Build connection parameters
+        connect_params = {
+            "model": self.model,
+            "encoding": "linear16",
+            "sample_rate": "16000",
+        }
+
+        # Add optional parameters if specified
+        if self.eot_threshold is not None:
+            connect_params["eot_threshold"] = str(self.eot_threshold)
+        if self.eager_eot_threshold is not None:
+            connect_params["eager_eot_threshold"] = str(self.eager_eot_threshold)
+
+        # Connect to Deepgram v2 listen WebSocket with timeout
+        self._connection_context = self.client.listen.v2.connect(**connect_params)
+
+        # Add timeout for connection establishment
+        self.connection = await asyncio.wait_for(
+            self._connection_context.__aenter__(), timeout=10.0
+        )
+
+        # Register event handlers
+        if self.connection is not None:
+            self.connection.on(EventType.OPEN, self._on_open)
+            self.connection.on(EventType.MESSAGE, self._on_message)
+            self.connection.on(EventType.ERROR, self._on_error)
+            self.connection.on(EventType.CLOSE, self._on_close)
+
+            # Start listening for events
+            self._listen_task = asyncio.create_task(self.connection.start_listening())
+
+        # Mark connection as ready
+        self._connection_ready.set()
+
+    def _on_message(self, message):
+        """
+        Event handler for messages from Deepgram.
+
+        Args:
+            message: The message object from Deepgram
+
+        TODO: errors in this function are hidden silently. Not sure why this happens.
+        """
+        # Extract message data
+        if not hasattr(message, "type"):
+            logger.warning(f"Received message without 'type' attribute: {message}")
+            return
+
+        # Handle TurnInfo messages (v2 API)
+        if message.type == "TurnInfo":
+            # Extract transcript text
+            transcript_text = getattr(message, "transcript", "").strip()
+
+            if not transcript_text:
+                return
+
+            # Get event type to determine if final or partial
+            # "StartOfTurn" and "Update" = partial, "EndOfTurn" = final
+            event = getattr(message, "event", "")
+
+            is_final = event == "EndOfTurn"
+            eager_end_of_turn = event == "EagerEndOfTurn"
+            start_of_turn = event == "StartOfTurn"
+
+            # Get end of turn confidence
+            end_of_turn_confidence = getattr(message, "end_of_turn_confidence", 0.0)
+
+            # Calculate average confidence from words
+            words = getattr(message, "words", [])
+            if words:
+                confidences = [w.confidence for w in words if hasattr(w, "confidence")]
+                avg_confidence = (
+                    sum(confidences) / len(confidences) if confidences else 0.0
+                )
+            else:
+                avg_confidence = 0.0
+
+            # Get audio duration
+            audio_window_end = getattr(message, "audio_window_end", 0.0)
+            duration_ms = int(audio_window_end * 1000)
+
+            # Build response metadata
+            response_metadata = TranscriptResponse(
+                confidence=avg_confidence,
+                language=self.language or "auto",
+                audio_duration_ms=duration_ms,
+                model_name=self.model,
+            )
+
+            # Use the participant from the most recent process_audio call
+            participant = self._current_participant
+
+            if participant is None:
+                logger.warning("Received transcript but no participant set")
+                return
+
+            # broadcast STT event first
+            if is_final:
+                self._emit_transcript_event(
+                    transcript_text, participant, response_metadata
+                )
+            else:
+                self._emit_partial_transcript_event(
+                    transcript_text, participant, response_metadata
+                )
+
+            # broadcast turn event
+            if is_final or eager_end_of_turn:
+                self._emit_turn_ended_event(
+                    participant=participant,
+                    eager_end_of_turn=eager_end_of_turn,
+                    confidence=end_of_turn_confidence,
+                )
+
+            if start_of_turn:
+                self._emit_turn_started_event(
+                    participant=participant, confidence=end_of_turn_confidence
+                )
+
+    def _on_open(self, message):
+        pass
+
+    def _on_error(self, error):
+        """
+        Event handler for errors from Deepgram.
+
+        Args:
+            error: The error from Deepgram
+        """
+        logger.error(f"Deepgram WebSocket error: {error}")
+        raise Exception(f"Deepgram WebSocket error {error}")
+
+    def _on_close(self, error):
+        """
+        Event handler for connection close.
+        """
+        logger.debug(f"Deepgram WebSocket connection closed: {error}")
+        self._connection_ready.clear()
+
+    async def close(self):
+        """
+        Close the Deepgram connection and clean up resources.
+        """
+        # Mark as closed first
+        await super().close()
+
+        # Cancel listen task
+        if self._listen_task and not self._listen_task.done():
+            self._listen_task.cancel()
+            await asyncio.gather(self._listen_task, return_exceptions=True)
+
+        # Close connection
+        if self.connection and self._connection_context:
+            close_msg = ListenV2ControlMessage(type="CloseStream")
+            await self.connection.send_control(close_msg)
+            await self._connection_context.__aexit__(None, None, None)
+            self.connection = None
+            self._connection_context = None
+            self._connection_ready.clear()

vision_agents/plugins/deepgram/tts.py

@@ -0,0 +1,90 @@
+import logging
+import os
+from typing import AsyncIterator, Optional
+
+from deepgram import AsyncDeepgramClient
+from getstream.video.rtc.track_util import PcmData, AudioFormat
+
+from vision_agents.core import tts
+
+logger = logging.getLogger(__name__)
+
+
+class TTS(tts.TTS):
+    """
+    Deepgram Text-to-Speech implementation using Aura model.
+
+    Uses the Deepgram Speak API with streaming response.
+
+    References:
+    - https://developers.deepgram.com/docs/text-to-speech
+    - https://developers.deepgram.com/docs/tts-models
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        model: str = "aura-2-thalia-en",
+        sample_rate: int = 16000,
+        client: Optional[AsyncDeepgramClient] = None,
+    ):
+        """
+        Initialize Deepgram TTS.
+
+        Args:
+            api_key: Deepgram API key. If not provided, will use DEEPGRAM_API_KEY env var.
+            model: Voice model to use. Defaults to "aura-2-thalia-en".
+                   See https://developers.deepgram.com/docs/tts-models for available voices.
+            sample_rate: Audio sample rate in Hz. Defaults to 16000.
+            client: Optional pre-configured AsyncDeepgramClient instance.
+        """
+        super().__init__(provider_name="deepgram")
+
+        if not api_key:
+            api_key = os.environ.get("DEEPGRAM_API_KEY")
+
+        if client is not None:
+            self.client = client
+        else:
+            if api_key:
+                self.client = AsyncDeepgramClient(api_key=api_key)
+            else:
+                self.client = AsyncDeepgramClient()
+
+        self.model = model
+        self.sample_rate = sample_rate
+
+    async def stream_audio(self, text: str, *_, **__) -> AsyncIterator[PcmData]:
+        """
+        Convert text to speech using Deepgram's Speak API.
+
+        Args:
+            text: The text to convert to speech.
+
+        Returns:
+            An async iterator of PcmData audio chunks.
+        """
+        # Use the Deepgram speak API with streaming response
+        response = self.client.speak.v1.audio.generate(
+            text=text,
+            model=self.model,
+            encoding="linear16",
+            sample_rate=self.sample_rate,
+            container="none",  # Raw PCM, no container
+        )
+
+        return PcmData.from_response(
+            response,
+            sample_rate=self.sample_rate,
+            channels=1,
+            format=AudioFormat.S16,
+        )
+
+    async def stop_audio(self) -> None:
+        """
+        Stop audio playback.
+
+        This is a no-op for Deepgram TTS as each stream_audio call
+        creates its own request.
+        """
+        pass

vision_agents_plugins_deepgram-0.2.7.dist-info/METADATA

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: vision-agents-plugins-deepgram
+Version: 0.2.7
+Summary: Deepgram STT and TTS integration for Vision Agents
+Project-URL: Documentation, https://visionagents.ai/
+Project-URL: Website, https://visionagents.ai/
+Project-URL: Source, https://github.com/GetStream/Vision-Agents
+License-Expression: MIT
+Keywords: AI,STT,TTS,agents,deepgram,speech-to-text,text-to-speech,transcription,voice agents
+Requires-Python: >=3.10
+Requires-Dist: deepgram-sdk>=5.3.0
+Requires-Dist: numpy<2.3,>=2.2.6
+Requires-Dist: vision-agents
+Description-Content-Type: text/markdown
+
+# Deepgram Plugin
+
+Speech-to-Text (STT) and Text-to-Speech (TTS) plugins for Vision Agents using the Deepgram API.
+
+## Installation
+
+```bash
+uv add vision-agents-plugins-deepgram
+```
+
+## Speech-to-Text (STT)
+
+High-quality speech recognition using Deepgram's Flux model with built-in turn detection.
+
+```python
+from vision_agents.plugins import deepgram
+
+stt = deepgram.STT(
+    model="flux-general-en",  # Default model
+    eager_turn_detection=True,  # Enable eager end-of-turn detection
+)
+```
+
+### STT Docs
+
+- https://developers.deepgram.com/docs/flux/quickstart
+- https://github.com/deepgram/deepgram-python-sdk/blob/main/examples/listen/v2/connect/async.py
+
+## Text-to-Speech (TTS)
+
+Low-latency text-to-speech using Deepgram's Aura model via WebSocket streaming.
+
+```python
+from vision_agents.plugins import deepgram
+
+tts = deepgram.TTS(
+    model="aura-2-thalia-en",  # Default voice
+    sample_rate=16000,  # Audio sample rate
+)
+```
+
+### Available Voices
+
+Deepgram offers various Aura voice models:
+- `aura-2-thalia-en` - Default female voice
+- `aura-2-orion-en` - Male voice
+- See [TTS Models](https://developers.deepgram.com/docs/tts-models) for all options
+
+### TTS Docs
+
+- https://developers.deepgram.com/docs/tts-websocket
+- https://developers.deepgram.com/docs/streaming-text-to-speech
+
+## Environment Variables
+
+Set `DEEPGRAM_API_KEY` in your environment or pass `api_key` to the constructor.
+
+## Example
+
+See the [example](./example/) directory for a complete working example using both STT and TTS.

vision_agents_plugins_deepgram-0.2.7.dist-info/RECORD

@@ -0,0 +1,13 @@
+./.gitignore,sha256=zrSq4X-Qh8j7QY0ukXt-RXj6StdhdbJdR3e8HoHbTTg,961
+./PKG-INFO,sha256=kH6bebh7sm4YoT5YJEwcLFtznB0IXs0jsnbve1d2OEA,2092
+./README.md,sha256=4YA-4sqnbnM4uRHV-QlpS7u2zMxK40tlMhj-K5dgaMw,1514
+./pyproject.toml,sha256=AukzbgN5ZSP0r3VdI1KNxYSXfSAV7-yZWHE2mLovucc,1132
+./vision_agents/plugins/deepgram/__init__.py,sha256=ceZaZdjlOqBn_aV1-MDZnJL9GEWXCPOIioC3ktp26o0,195
+./vision_agents/plugins/deepgram/deepgram_stt.py,sha256=5NbgHmdPBdML5F-pl1v5qu87yz9j5tOK3RYdLdzeetw,10671
+./vision_agents/plugins/deepgram/tts.py,sha256=ih5k_pV9rUMBswEJ1na_9lIwjzT49NAlDZbZItijerU,2645
+vision_agents/plugins/deepgram/__init__.py,sha256=ceZaZdjlOqBn_aV1-MDZnJL9GEWXCPOIioC3ktp26o0,195
+vision_agents/plugins/deepgram/deepgram_stt.py,sha256=5NbgHmdPBdML5F-pl1v5qu87yz9j5tOK3RYdLdzeetw,10671
+vision_agents/plugins/deepgram/tts.py,sha256=ih5k_pV9rUMBswEJ1na_9lIwjzT49NAlDZbZItijerU,2645
+vision_agents_plugins_deepgram-0.2.7.dist-info/METADATA,sha256=kH6bebh7sm4YoT5YJEwcLFtznB0IXs0jsnbve1d2OEA,2092
+vision_agents_plugins_deepgram-0.2.7.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+vision_agents_plugins_deepgram-0.2.7.dist-info/RECORD,,

vision_agents_plugins_deepgram-0.2.7.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any