atom-audio-engine 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

audio_engine/tests/test_traditional_pipeline/test_pipeline_creation.py

@@ -1,64 +0,0 @@
-"""Tests for Pipeline creation from config."""
-
-import pytest
-from core.config import AudioEngineConfig
-from core.pipeline import Pipeline
-
-
-class TestPipelineCreation:
-    """Test Pipeline creation from AudioEngineConfig."""
-
-    def test_create_pipeline_from_config(self):
-        """Does config.create_pipeline() create a Pipeline instance?"""
-        config = AudioEngineConfig.from_env()
-
-        pipeline = config.create_pipeline(system_prompt="Test prompt")
-
-        assert isinstance(pipeline, Pipeline)
-
-    def test_pipeline_has_all_providers(self):
-        """Does Pipeline have ASR, LLM, and TTS providers initialized?"""
-        config = AudioEngineConfig.from_env()
-
-        pipeline = config.create_pipeline()
-
-        assert pipeline.asr is not None
-        assert pipeline.llm is not None
-        assert pipeline.tts is not None
-
-    def test_pipeline_has_correct_provider_types(self):
-        """Does Pipeline have correct provider types?"""
-        config = AudioEngineConfig.from_env()
-
-        pipeline = config.create_pipeline()
-
-        assert pipeline.asr.__class__.__name__ == "CartesiaASR"
-        assert pipeline.llm.__class__.__name__ == "GroqLLM"
-        assert pipeline.tts.__class__.__name__ == "CartesiaTTS"
-
-    def test_pipeline_system_prompt_set(self):
-        """Does pipeline.context have system_prompt set?"""
-        prompt = "You are a helpful assistant"
-        config = AudioEngineConfig.from_env()
-
-        pipeline = config.create_pipeline(system_prompt=prompt)
-
-        assert pipeline.context.system_prompt == prompt
-
-    def test_pipeline_default_system_prompt_from_config(self):
-        """Does pipeline use config system_prompt as default?"""
-        config = AudioEngineConfig.from_env()
-        config.llm.system_prompt = "Config default prompt"
-
-        pipeline = config.create_pipeline()
-
-        assert pipeline.context.system_prompt == "Config default prompt"
-
-    def test_pipeline_system_prompt_override(self):
-        """Does explicit system_prompt override config default?"""
-        config = AudioEngineConfig.from_env()
-        config.llm.system_prompt = "Config default"
-
-        pipeline = config.create_pipeline(system_prompt="Override prompt")
-
-        assert pipeline.context.system_prompt == "Override prompt"

audio_engine/tests/test_traditional_pipeline/test_pipeline_with_mocks.py

@@ -1,173 +0,0 @@
-"""Tests for Pipeline with mocked providers."""
-
-import pytest
-from unittest.mock import AsyncMock, MagicMock
-from core.pipeline import Pipeline
-from core.types import AudioChunk, TranscriptChunk, ResponseChunk, AudioFormat
-from asr.base import BaseASR
-from llm.base import BaseLLM
-from tts.base import BaseTTS
-
-
-class MockASR(BaseASR):
-    """Mock ASR provider for testing."""
-
-    @property
-    def name(self):
-        return "mock_asr"
-
-    async def transcribe(self, audio: bytes, sample_rate: int = 16000) -> str:
-        return "Hello"
-
-    async def transcribe_stream(self, audio_stream):
-        yield TranscriptChunk(text="Hello", confidence=0.95, is_final=True)
-
-
-class MockLLM(BaseLLM):
-    """Mock LLM provider for testing."""
-
-    @property
-    def name(self):
-        return "mock_llm"
-
-    async def generate(self, prompt: str, context=None) -> str:
-        return "Hi there"
-
-    async def generate_stream(self, prompt: str, context=None):
-        yield ResponseChunk(text="Hi there", is_final=True)
-
-
-class MockTTS(BaseTTS):
-    """Mock TTS provider for testing."""
-
-    @property
-    def name(self):
-        return "mock_tts"
-
-    async def synthesize(self, text: str) -> bytes:
-        return b"audio_bytes"
-
-    async def synthesize_stream(self, text: str):
-        yield AudioChunk(
-            data=b"audio_bytes",
-            sample_rate=24000,
-            channels=1,
-            format=AudioFormat.PCM_24K,
-            timestamp_ms=0,
-            is_final=True,
-        )
-
-    async def synthesize_stream_text(self, text_stream):
-        async for text in text_stream:
-            yield AudioChunk(
-                data=b"audio_chunk",
-                sample_rate=24000,
-                channels=1,
-                format=AudioFormat.PCM_24K,
-                timestamp_ms=0,
-                is_final=True,
-            )
-
-
-@pytest.mark.asyncio
-class TestPipelineWithMocks:
-    """Test Pipeline with mocked providers."""
-
-    async def test_pipeline_process_calls_providers_in_order(self):
-        """Does pipeline.process() call ASR → LLM → TTS in order?"""
-        asr = MockASR(api_key="test")
-        llm = MockLLM(api_key="test")
-        tts = MockTTS(api_key="test")
-
-        pipeline = Pipeline(asr=asr, llm=llm, tts=tts)
-
-        # Mock the methods to track calls
-        asr.transcribe = AsyncMock(return_value="Hello")
-        llm.generate = AsyncMock(return_value="Hi there")
-        tts.synthesize = AsyncMock(return_value=b"audio_bytes")
-
-        result = await pipeline.process(b"audio_data")
-
-        assert result == b"audio_bytes"
-        assert asr.transcribe.called
-        assert llm.generate.called
-        assert tts.synthesize.called
-
-    async def test_pipeline_process_adds_user_message_to_context(self):
-        """Does pipeline.process() add user message to context?"""
-        asr = MockASR(api_key="test")
-        llm = MockLLM(api_key="test")
-        tts = MockTTS(api_key="test")
-
-        asr.transcribe = AsyncMock(return_value="User said this")
-        llm.generate = AsyncMock(return_value="Response")
-        tts.synthesize = AsyncMock(return_value=b"audio")
-
-        pipeline = Pipeline(asr=asr, llm=llm, tts=tts)
-        await pipeline.process(b"audio_data")
-
-        messages = pipeline.context.messages
-        assert len(messages) >= 1
-        assert messages[0].role == "user"
-        assert messages[0].content == "User said this"
-
-    async def test_pipeline_process_adds_assistant_message_to_context(self):
-        """Does pipeline.process() add assistant message to context?"""
-        asr = MockASR(api_key="test")
-        llm = MockLLM(api_key="test")
-        tts = MockTTS(api_key="test")
-
-        asr.transcribe = AsyncMock(return_value="Hello")
-        llm.generate = AsyncMock(return_value="Assistant response")
-        tts.synthesize = AsyncMock(return_value=b"audio")
-
-        pipeline = Pipeline(asr=asr, llm=llm, tts=tts)
-        await pipeline.process(b"audio_data")
-
-        messages = pipeline.context.messages
-        assert len(messages) >= 2
-        assert messages[1].role == "assistant"
-        assert messages[1].content == "Assistant response"
-
-    async def test_pipeline_stream_works_with_mocks(self):
-        """Does pipeline.stream() work with mocked providers?"""
-        asr = MockASR(api_key="test")
-        llm = MockLLM(api_key="test")
-        tts = MockTTS(api_key="test")
-
-        pipeline = Pipeline(asr=asr, llm=llm, tts=tts)
-
-        # Create a simple async generator for audio input
-        async def mock_audio_stream():
-            yield AudioChunk(
-                data=b"audio",
-                sample_rate=16000,
-                channels=1,
-                format=AudioFormat.PCM_16K,
-                timestamp_ms=0,
-                is_final=True,
-            )
-
-        chunks = []
-        async for chunk in pipeline.stream(mock_audio_stream()):
-            chunks.append(chunk)
-
-        assert len(chunks) > 0
-
-    async def test_pipeline_reset_context_clears_messages(self):
-        """Does pipeline.reset_context() clear conversation history?"""
-        asr = MockASR(api_key="test")
-        llm = MockLLM(api_key="test")
-        tts = MockTTS(api_key="test")
-
-        asr.transcribe = AsyncMock(return_value="Hello")
-        llm.generate = AsyncMock(return_value="Hi")
-        tts.synthesize = AsyncMock(return_value=b"audio")
-
-        pipeline = Pipeline(asr=asr, llm=llm, tts=tts)
-
-        await pipeline.process(b"audio_data")
-        assert len(pipeline.context.messages) > 0
-
-        pipeline.reset_context()
-        assert len(pipeline.context.messages) == 0

audio_engine/tests/test_traditional_pipeline/test_provider_factories.py

@@ -1,61 +0,0 @@
-"""Tests for provider factory functions."""
-
-import pytest
-from core.config import ASRConfig, LLMConfig, TTSConfig
-from asr import get_asr_from_config
-from llm import get_llm_from_config
-from tts import get_tts_from_config
-
-
-class TestProviderFactories:
-    """Test provider factory functions."""
-
-    def test_get_asr_from_config_deepgram(self):
-        """Does get_asr_from_config() create DeepgramASR for deepgram provider?"""
-        config = ASRConfig(provider="deepgram", api_key="test-key")
-
-        asr = get_asr_from_config(config)
-
-        assert asr.__class__.__name__ == "DeepgramASR"
-        assert asr.api_key == "test-key"
-
-    def test_get_llm_from_config_groq(self):
-        """Does get_llm_from_config() create GroqLLM for groq provider?"""
-        config = LLMConfig(
-            provider="groq", api_key="test-key", model="llama-3.1-8b-instant"
-        )
-
-        llm = get_llm_from_config(config)
-
-        assert llm.__class__.__name__ == "GroqLLM"
-        assert llm.api_key == "test-key"
-
-    def test_get_tts_from_config_cartesia(self):
-        """Does get_tts_from_config() create CartesiaTTS for cartesia provider?"""
-        config = TTSConfig(provider="cartesia", api_key="test-key", voice_id="sonic")
-
-        tts = get_tts_from_config(config)
-
-        assert tts.__class__.__name__ == "CartesiaTTS"
-        assert tts.api_key == "test-key"
-
-    def test_get_asr_from_config_unknown_provider(self):
-        """Does get_asr_from_config() raise error for unknown provider?"""
-        config = ASRConfig(provider="unknown_provider", api_key="test-key")
-
-        with pytest.raises(ValueError):
-            get_asr_from_config(config)
-
-    def test_get_llm_from_config_unknown_provider(self):
-        """Does get_llm_from_config() raise error for unknown provider?"""
-        config = LLMConfig(provider="unknown_provider", api_key="test-key")
-
-        with pytest.raises(ValueError):
-            get_llm_from_config(config)
-
-    def test_get_tts_from_config_unknown_provider(self):
-        """Does get_tts_from_config() raise error for unknown provider?"""
-        config = TTSConfig(provider="unknown_provider", api_key="test-key")
-
-        with pytest.raises(ValueError):
-            get_tts_from_config(config)

audio_engine/tests/test_traditional_pipeline/test_websocket_server.py

@@ -1,58 +0,0 @@
-"""Tests for WebSocket server initialization."""
-
-import pytest
-from core.config import AudioEngineConfig
-from streaming.websocket_server import WebSocketServer
-
-
-class TestWebSocketServerCreation:
-    """Test WebSocket server creation from config."""
-
-    def test_websocket_server_init(self):
-        """Can we create a WebSocketServer instance?"""
-        config = AudioEngineConfig.from_env()
-        pipeline = config.create_pipeline()
-
-        server = WebSocketServer(pipeline, host="localhost", port=8765)
-
-        assert server is not None
-        assert server.host == "localhost"
-        assert server.port == 8765
-
-    def test_websocket_server_has_pipeline(self):
-        """Does WebSocketServer store the pipeline?"""
-        config = AudioEngineConfig.from_env()
-        pipeline = config.create_pipeline()
-
-        server = WebSocketServer(pipeline)
-
-        assert server.pipeline == pipeline
-
-    def test_websocket_server_default_host_port(self):
-        """Does WebSocketServer use default host/port?"""
-        config = AudioEngineConfig.from_env()
-        pipeline = config.create_pipeline()
-
-        server = WebSocketServer(pipeline)
-
-        assert server.host == "0.0.0.0"
-        assert server.port == 8765
-
-    def test_websocket_server_custom_host_port(self):
-        """Can we set custom host/port on WebSocketServer?"""
-        config = AudioEngineConfig.from_env()
-        pipeline = config.create_pipeline()
-
-        server = WebSocketServer(pipeline, host="127.0.0.1", port=9000)
-
-        assert server.host == "127.0.0.1"
-        assert server.port == 9000
-
-    def test_run_server_config_host_port(self):
-        """Does run_server_from_config() use config host/port?"""
-        config = AudioEngineConfig.from_env()
-        config.streaming.host = "192.168.1.1"
-        config.streaming.port = 9999
-
-        assert config.streaming.host == "192.168.1.1"
-        assert config.streaming.port == 9999

audio_engine/tts/__init__.py

@@ -1,37 +0,0 @@
-"""TTS (Text-to-Speech) providers."""
-
-from core.config import TTSConfig
-
-from .base import BaseTTS
-from .cartesia import CartesiaTTS
-
-__all__ = ["BaseTTS", "CartesiaTTS", "get_tts_from_config"]
-
-
-def get_tts_from_config(config: TTSConfig) -> BaseTTS:
-    """
-    Instantiate TTS provider from config.
-
-    Args:
-        config: TTSConfig object with provider name and settings
-
-    Returns:
-        Initialized BaseTTS provider instance
-
-    Raises:
-        ValueError: If provider name is not recognized
-    """
-    provider_name = config.provider.lower()
-
-    if provider_name == "cartesia":
-        return CartesiaTTS(
-            api_key=config.api_key,
-            voice_id=config.voice_id,  # None will use DEFAULT_VOICE_ID in CartesiaTTS
-            model=config.model or "sonic-3",
-            speed=config.speed,
-            **config.extra,
-        )
-    else:
-        raise ValueError(
-            f"Unknown TTS provider: {config.provider}. " f"Supported: cartesia"
-        )

audio_engine/tts/base.py

@@ -1,155 +0,0 @@
-"""Abstract base class for TTS (Text-to-Speech) providers."""
-
-from abc import ABC, abstractmethod
-from typing import AsyncIterator, Optional
-
-from core.types import AudioChunk, AudioFormat
-
-
-class BaseTTS(ABC):
-    """
-    Abstract base class for Text-to-Speech providers.
-
-    All TTS implementations must inherit from this class and implement
-    the required methods for both batch and streaming audio synthesis.
-    """
-
-    def __init__(
-        self,
-        api_key: Optional[str] = None,
-        voice_id: Optional[str] = None,
-        model: Optional[str] = None,
-        speed: float = 1.0,
-        output_format: AudioFormat = AudioFormat.PCM_24K,
-        **kwargs
-    ):
-        """
-        Initialize the TTS provider.
-
-        Args:
-            api_key: API key for the provider
-            voice_id: Voice identifier to use
-            model: Model identifier (if applicable)
-            speed: Speech speed multiplier (1.0 = normal)
-            output_format: Desired audio output format
-            **kwargs: Additional provider-specific configuration
-        """
-        self.api_key = api_key
-        self.voice_id = voice_id
-        self.model = model
-        self.speed = speed
-        self.output_format = output_format
-        self.config = kwargs
-
-    @abstractmethod
-    async def synthesize(self, text: str) -> bytes:
-        """
-        Synthesize complete audio from text.
-
-        Args:
-            text: Text to convert to speech
-
-        Returns:
-            Complete audio as bytes
-        """
-        pass
-
-    @abstractmethod
-    async def synthesize_stream(self, text: str) -> AsyncIterator[AudioChunk]:
-        """
-        Synthesize streaming audio from text.
-
-        Args:
-            text: Text to convert to speech
-
-        Yields:
-            AudioChunk objects with audio data
-        """
-        pass
-
-    async def synthesize_stream_text(
-        self, text_stream: AsyncIterator[str]
-    ) -> AsyncIterator[AudioChunk]:
-        """
-        Synthesize streaming audio from streaming text input.
-
-        This enables sentence-by-sentence TTS as the LLM generates text.
-        Default implementation buffers until punctuation. Override for
-        providers with native text streaming support.
-
-        Args:
-            text_stream: Async iterator yielding text chunks
-
-        Yields:
-            AudioChunk objects with audio data
-        """
-        buffer = ""
-        sentence_enders = ".!?;"
-
-        async for text_chunk in text_stream:
-            buffer += text_chunk
-
-            # Check if we have a complete sentence
-            for ender in sentence_enders:
-                if ender in buffer:
-                    # Split at the sentence boundary
-                    parts = buffer.split(ender, 1)
-                    sentence = parts[0] + ender
-
-                    if sentence.strip():
-                        async for audio_chunk in self.synthesize_stream(
-                            sentence.strip()
-                        ):
-                            yield audio_chunk
-
-                    buffer = parts[1] if len(parts) > 1 else ""
-                    break
-
-        # Handle remaining text
-        if buffer.strip():
-            async for audio_chunk in self.synthesize_stream(buffer.strip()):
-                yield audio_chunk
-
-    async def __aenter__(self):
-        """Async context manager entry."""
-        await self.connect()
-        return self
-
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        """Async context manager exit."""
-        await self.disconnect()
-
-    async def connect(self):
-        """
-        Establish connection to the TTS service.
-        Override in subclasses if needed.
-        """
-        pass
-
-    async def disconnect(self):
-        """
-        Close connection to the TTS service.
-        Override in subclasses if needed.
-        """
-        pass
-
-    @property
-    @abstractmethod
-    def name(self) -> str:
-        """Return the name of this TTS provider."""
-        pass
-
-    @property
-    def supports_streaming(self) -> bool:
-        """Whether this provider supports streaming audio output."""
-        return True
-
-    @property
-    def sample_rate(self) -> int:
-        """Return the sample rate for this provider's output."""
-        format_rates = {
-            AudioFormat.PCM_16K: 16000,
-            AudioFormat.PCM_24K: 24000,
-            AudioFormat.PCM_44K: 44100,
-        }
-        return format_rates.get(self.output_format, 24000)