atom-audio-engine 0.1.2__py3-none-any.whl → 0.1.5__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