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

audio_engine/scripts/debug_tts.py

@@ -1,162 +0,0 @@
-#!/usr/bin/env python3
-"""
-Debug script: Test CartesiaTTS in isolation
-"""
-
-import asyncio
-import sys
-import logging
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).parent))
-
-from dotenv import load_dotenv
-from tts.cartesia import CartesiaTTS
-
-# Load env variables
-load_dotenv()
-
-# Setup logging
-logging.basicConfig(
-    level=logging.DEBUG, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-)
-logger = logging.getLogger(__name__)
-
-
-async def test_simple_text():
-    """Test simple text-to-speech."""
-    logger.info("=" * 70)
-    logger.info("TEST: Simple Text-to-Speech")
-    logger.info("=" * 70)
-
-    tts = CartesiaTTS(
-        api_key=None,  # Will use env var
-        voice_id=None,  # Will use default
-        model="sonic-3",
-        sample_rate=16000,
-    )
-
-    logger.info(f"TTS Config:")
-    logger.info(f"  API Key: {tts.api_key}")
-    logger.info(f"  Voice ID: {tts.voice_id}")
-    logger.info(f"  Model: {tts.model}")
-    logger.info(f"  Sample Rate: {tts.sample_rate}")
-
-    try:
-        logger.info("\nCalling synthesize_stream_text with simple text...")
-
-        async def text_gen():
-            yield "Hello "
-            yield "world"
-
-        chunk_count = 0
-        total_bytes = 0
-
-        async for chunk in tts.synthesize_stream_text(text_gen()):
-            chunk_count += 1
-            if chunk.data:
-                total_bytes += len(chunk.data)
-                logger.info(
-                    f"✓ Got audio chunk {chunk_count}: {len(chunk.data)} bytes, is_final={chunk.is_final}"
-                )
-            else:
-                logger.info(f"✓ Got final marker: is_final={chunk.is_final}")
-
-        logger.info(f"\n✓ SUCCESS: Got {chunk_count} chunks, {total_bytes} bytes total")
-
-    except Exception as e:
-        logger.error(f"✗ FAILED: {type(e).__name__}: {e}", exc_info=True)
-        return False
-
-    return True
-
-
-async def test_with_queue():
-    """Test using asyncio.Queue like the original example."""
-    logger.info("\n" + "=" * 70)
-    logger.info("TEST: With asyncio.Queue (like StreamingService)")
-    logger.info("=" * 70)
-
-    tts = CartesiaTTS(
-        api_key=None,
-        voice_id=None,
-        model="sonic-3",
-        sample_rate=16000,
-    )
-
-    queue = asyncio.Queue()
-
-    async def text_producer():
-        """Simulate LLM producing text tokens."""
-        tokens = ["Hello ", "world", "!"]
-        for token in tokens:
-            logger.info(f"📤 Producing: {token!r}")
-            await queue.put(token)
-        logger.info("📤 Putting None to signal end")
-        await queue.put(None)
-
-    async def queue_to_async_iter():
-        """Convert queue to async iterator."""
-        while True:
-            token = await queue.get()
-            if token is None:
-                break
-            yield token
-
-    try:
-        logger.info("\nStarting text producer and TTS consumer...")
-
-        producer_task = asyncio.create_task(text_producer())
-
-        chunk_count = 0
-        total_bytes = 0
-
-        async for chunk in tts.synthesize_stream_text(queue_to_async_iter()):
-            chunk_count += 1
-            if chunk.data:
-                total_bytes += len(chunk.data)
-                logger.info(f"✓ Got audio chunk {chunk_count}: {len(chunk.data)} bytes")
-            else:
-                logger.info(f"✓ Got final marker")
-
-        await producer_task
-
-        logger.info(f"\n✓ SUCCESS: Got {chunk_count} chunks, {total_bytes} bytes total")
-        return True
-
-    except Exception as e:
-        logger.error(f"✗ FAILED: {type(e).__name__}: {e}", exc_info=True)
-        return False
-
-
-async def main():
-    logger.info("\n")
-    logger.info("╔" + "=" * 68 + "╗")
-    logger.info("║" + " " * 15 + "CARTESIA TTS DEBUG TEST" + " " * 31 + "║")
-    logger.info("╚" + "=" * 68 + "╝")
-
-    results = []
-
-    # Test 1: Simple text
-    results.append(("Simple text-to-speech", await test_simple_text()))
-
-    # Test 2: Queue-based
-    results.append(("Queue-based streaming", await test_with_queue()))
-
-    # Summary
-    logger.info("\n" + "=" * 70)
-    logger.info("SUMMARY")
-    logger.info("=" * 70)
-    for test_name, passed in results:
-        status = "✓ PASS" if passed else "✗ FAIL"
-        logger.info(f"{status}: {test_name}")
-
-    all_passed = all(result for _, result in results)
-    logger.info("=" * 70)
-
-    return 0 if all_passed else 1
-
-
-if __name__ == "__main__":
-    exit_code = asyncio.run(main())
-    sys.exit(exit_code)

audio_engine/scripts/test_cartesia_connect.py

@@ -1,57 +0,0 @@
-#!/usr/bin/env python3
-"""Test Cartesia WebSocket connection and capture error message."""
-
-import asyncio
-import logging
-from pathlib import Path
-from urllib.parse import quote
-
-import websockets
-from websockets.exceptions import InvalidStatus
-
-# Setup logging
-logging.basicConfig(level=logging.DEBUG)
-
-# Load env
-from dotenv import load_dotenv
-import os
-
-load_dotenv(Path(__file__).parent.parent / ".env")
-
-CARTESIA_API_KEY = os.getenv("CARTESIA_API_KEY")
-
-
-async def test_connection():
-    """Test Cartesia WebSocket connection."""
-    url = (
-        f"wss://api.cartesia.ai/stt/websocket?"
-        f"model={quote('ink-whisper')}"
-        f"&language={quote('en')}"
-        f"&encoding={quote('pcm_s16le')}"
-        f"&sample_rate={quote('16000')}"
-        f"&min_volume={quote('0.0')}"
-        f"&max_silence_duration_secs={quote('30.0')}"
-        f"&api_key={quote(CARTESIA_API_KEY)}"
-    )
-
-    print(f"Connecting to: {url}\n")
-
-    try:
-        async with websockets.connect(url, open_timeout=30) as ws:
-            print("✓ Connected!")
-    except InvalidStatus as e:
-        print(f"✗ Invalid Status Error")
-        print(f"  Response object: {e.response}")
-        print(
-            f"  Response dir: {[attr for attr in dir(e.response) if not attr.startswith('_')]}"
-        )
-        print(f"  Exception str: {str(e)}")
-    except Exception as e:
-        print(f"✗ Connection failed: {e}")
-        import traceback
-
-        traceback.print_exc()
-
-
-if __name__ == "__main__":
-    asyncio.run(test_connection())

audio_engine/tests/__init__.py

@@ -1 +0,0 @@
-"""Tests for the audio engine."""

audio_engine/tests/test_personaplex/__init__.py

@@ -1 +0,0 @@
-"""Tests for the audio engine."""

audio_engine/tests/test_personaplex/test_personaplex.py

@@ -1,10 +0,0 @@
-"""PersonaPlex test suite.
-
-Organized by step for maintainability:
-- test_personaplex_config.py     (Step 1: Config)
-- test_personaplex_message.py    (Step 2: Message encoding/decoding)
-- test_personaplex_transcript.py (Step 3: Transcript save/load)
-- test_personaplex_session.py    (Step 4: Session management)
-- test_personaplex_client.py     (Step 5: Client connection)
-- test_personaplex_pipeline.py   (Step 6-7: Pipeline lifecycle + mock messages)
-"""

audio_engine/tests/test_personaplex/test_personaplex_client.py

@@ -1,259 +0,0 @@
-"""Tests for PersonaPlexClient WebSocket connection (Step 5)."""
-
-import pytest
-from unittest.mock import AsyncMock, patch
-import asyncio
-
-from pipelines.personaplex import PersonaPlexClient, PersonaPlexConfig
-
-
-class TestPersonaPlexClientInit:
-    """Test client initialization and URL building."""
-
-    def test_client_init_with_defaults(self):
-        """Can we create a client with default config?"""
-        config = PersonaPlexConfig()
-        client = PersonaPlexClient(config)
-
-        assert client.config == config
-        assert client.connection is None
-        assert not client._is_connected
-
-    def test_client_init_with_custom_config(self):
-        """Can we create a client with custom config?"""
-        config = PersonaPlexConfig(
-            server_url="wss://custom.example.com",
-            voice_prompt="NATM0.pt",
-        )
-        client = PersonaPlexClient(config)
-
-        assert client.config.server_url == "wss://custom.example.com"
-        assert client.config.voice_prompt == "NATM0.pt"
-
-    def test_url_building_includes_voice_prompt(self):
-        """Does URL building include voice_prompt parameter?"""
-        config = PersonaPlexConfig(voice_prompt="NATF0.pt")
-        client = PersonaPlexClient(config)
-
-        url = client._build_url("Test prompt")
-
-        assert "voice_prompt=NATF0.pt" in url
-        assert "text_prompt=" in url
-
-    def test_url_building_includes_temperatures(self):
-        """Does URL include temperature parameters?"""
-        config = PersonaPlexConfig(
-            text_temperature=0.5,
-            audio_temperature=0.9,
-        )
-        client = PersonaPlexClient(config)
-
-        url = client._build_url("Test prompt")
-
-        assert "text_temperature=0.5" in url
-        assert "audio_temperature=0.9" in url
-
-    def test_url_building_encodes_system_prompt(self):
-        """Is system prompt included in URL?"""
-        config = PersonaPlexConfig()
-        client = PersonaPlexClient(config)
-
-        url = client._build_url("Hello world!")
-
-        assert "text_prompt=" in url
-
-
-@pytest.mark.asyncio
-class TestPersonaPlexClientConnection:
-    """Test client WebSocket connection lifecycle."""
-
-    async def test_connect_opens_websocket(self):
-        """Does connect establish a WebSocket?"""
-        config = PersonaPlexConfig()
-        client = PersonaPlexClient(config)
-
-        with patch("websockets.connect", new_callable=AsyncMock) as mock_connect:
-            mock_conn = AsyncMock()
-            mock_connect.return_value = mock_conn
-
-            await client.connect("Hello assistant")
-
-            assert client._is_connected
-            mock_connect.assert_called_once()
-
-    async def test_disconnect_closes_websocket(self):
-        """Does disconnect close the WebSocket?"""
-        config = PersonaPlexConfig()
-        client = PersonaPlexClient(config)
-
-        mock_conn = AsyncMock()
-        client.connection = mock_conn
-        client._is_connected = True
-
-        await client.disconnect()
-
-        mock_conn.close.assert_called_once()
-        assert not client._is_connected
-        assert client.connection is None
-
-    async def test_context_manager_exits_cleanly(self):
-        """Does context manager call disconnect on exit?"""
-        config = PersonaPlexConfig()
-        client = PersonaPlexClient(config)
-
-        # Manually set up connection
-        mock_conn = AsyncMock()
-        client.connection = mock_conn
-        client._is_connected = True
-
-        async with client:
-            # Still connected during the context
-            assert client._is_connected
-
-        # Should be disconnected after exiting
-        mock_conn.close.assert_called_once()
-        assert not client._is_connected
-
-
-@pytest.mark.asyncio
-class TestPersonaPlexClientSendReceive:
-    """Test sending and receiving data."""
-
-    async def test_send_audio_creates_message(self):
-        """Does send_audio create a binary message?"""
-        config = PersonaPlexConfig()
-        client = PersonaPlexClient(config)
-
-        mock_conn = AsyncMock()
-        client.connection = mock_conn
-        client._is_connected = True
-
-        audio_data = b"fake_opus_data"
-        await client.send_audio(audio_data)
-
-        mock_conn.send.assert_called_once()
-        sent_data = mock_conn.send.call_args[0][0]
-
-        # Should start with 0x01 (audio type)
-        assert sent_data[0] == 0x01
-        assert sent_data[1:] == audio_data
-
-    async def test_receive_audio_parses_message(self):
-        """Does receive_audio return AudioChunk?"""
-        config = PersonaPlexConfig()
-        client = PersonaPlexClient(config)
-
-        # Create a raw audio message (0x01 + audio data)
-        audio_data = b"received_opus"
-        raw_message = bytes([0x01]) + audio_data
-
-        mock_conn = AsyncMock()
-        mock_conn.recv.return_value = raw_message
-        client.connection = mock_conn
-        client._is_connected = True
-
-        from pipelines.personaplex import AudioChunk
-
-        chunk = await client.receive_audio()
-
-        assert isinstance(chunk, AudioChunk)
-        assert chunk.data == audio_data
-        assert chunk.sample_rate == 48000
-
-    async def test_receive_text_parses_message(self):
-        """Does receive_text return TextChunk?"""
-        config = PersonaPlexConfig()
-        client = PersonaPlexClient(config)
-
-        # Create a raw text message (0x02 + UTF-8 text)
-        text = "Hello from server"
-        raw_message = bytes([0x02]) + text.encode("utf-8")
-
-        mock_conn = AsyncMock()
-        mock_conn.recv.return_value = raw_message
-        client.connection = mock_conn
-        client._is_connected = True
-
-        from pipelines.personaplex import TextChunk
-
-        chunk = await client.receive_text()
-
-        assert isinstance(chunk, TextChunk)
-        assert chunk.text == text
-
-    async def test_receive_error_returns_none(self):
-        """Does receive_audio handle error messages gracefully?"""
-        config = PersonaPlexConfig()
-        client = PersonaPlexClient(config)
-
-        # Create an error message (0x05 + error text)
-        error_text = "Connection failed"
-        raw_message = bytes([0x05]) + error_text.encode("utf-8")
-
-        mock_conn = AsyncMock()
-        mock_conn.recv.return_value = raw_message
-        client.connection = mock_conn
-        client._is_connected = True
-
-        result = await client.receive_audio()
-
-        # Should return None, not raise
-        assert result is None
-
-
-@pytest.mark.asyncio
-class TestPersonaPlexClientStreaming:
-    """Test streaming message handling."""
-
-    async def test_stream_messages_yields_raw_messages(self):
-        """Does stream_messages yield PersonaPlexMessage objects?"""
-        from pipelines.personaplex import PersonaPlexMessage, MessageType
-
-        config = PersonaPlexConfig()
-        client = PersonaPlexClient(config)
-
-        # Create mock messages - raw bytes
-        audio_msg = bytes([0x01]) + b"audio_data"
-        text_msg = bytes([0x02]) + "Hello".encode("utf-8")
-
-        # Mock connection returns bytes
-        mock_conn = AsyncMock()
-        mock_conn.__aiter__.return_value = [audio_msg, text_msg]
-        client.connection = mock_conn
-        client._is_connected = True
-
-        messages = []
-        try:
-            async for msg in client.stream_messages():
-                messages.append(msg)
-                if len(messages) >= 2:
-                    break
-        except (StopAsyncIteration, asyncio.CancelledError):
-            pass
-
-        # Should get 2 PersonaPlexMessage objects
-        assert len(messages) == 2
-        assert messages[0].type == MessageType.AUDIO
-        assert messages[1].type == MessageType.TEXT
-
-    async def test_stream_messages_skips_errors(self):
-        """Does stream_messages skip error messages?"""
-        config = PersonaPlexConfig()
-        client = PersonaPlexClient(config)
-
-        # Error message type (0x05)
-        error_msg = bytes([0x05]) + b"Server error"
-
-        mock_conn = AsyncMock()
-        mock_conn.recv.return_value = error_msg
-        client.connection = mock_conn
-        client._is_connected = True
-
-        chunks = []
-        async for chunk in client.stream_messages():
-            chunks.append(chunk)
-            if len(chunks) > 1:  # Prevent infinite loop
-                break
-
-        # Error should be skipped (logged), not returned as chunk
-        assert len(chunks) == 0

audio_engine/tests/test_personaplex/test_personaplex_config.py

@@ -1,71 +0,0 @@
-"""Tests for PersonaPlexConfig (Step 1)."""
-
-import pytest
-from pathlib import Path
-from pipelines.personaplex import PersonaPlexConfig
-
-
-class TestPersonaPlexConfig:
-    """Test PersonaPlexConfig creation and validation."""
-
-    def test_default_creation(self):
-        """Can we create PersonaPlexConfig with defaults?"""
-        config = PersonaPlexConfig()
-        assert config.voice_prompt == "NATF0.pt"
-        assert config.text_temperature == 0.7
-        assert config.audio_temperature == 0.8
-        assert config.sample_rate == 48000
-
-    def test_custom_values(self):
-        """Can we create config with custom values?"""
-        config = PersonaPlexConfig(
-            voice_prompt="NATM1.pt",
-            text_temperature=0.5,
-            audio_temperature=0.9,
-        )
-        assert config.voice_prompt == "NATM1.pt"
-        assert config.text_temperature == 0.5
-        assert config.audio_temperature == 0.9
-
-    def test_reject_invalid_text_temp(self):
-        """Does it reject text_temperature > 2.0?"""
-        with pytest.raises(ValueError):
-            PersonaPlexConfig(text_temperature=2.5)
-
-    def test_reject_invalid_audio_temp(self):
-        """Does it reject audio_temperature < 0.0?"""
-        with pytest.raises(ValueError):
-            PersonaPlexConfig(audio_temperature=-0.1)
-
-    def test_reject_invalid_topk(self):
-        """Does it reject invalid top-K values?"""
-        with pytest.raises(ValueError):
-            PersonaPlexConfig(text_topk=0)
-
-    def test_reject_invalid_sample_rate(self):
-        """Does it reject invalid sample rates?"""
-        with pytest.raises(ValueError):
-            PersonaPlexConfig(sample_rate=22050)
-
-    def test_from_dict(self):
-        """Can we load config from a dictionary?"""
-        data = {
-            "voice_prompt": "NATF2.pt",
-            "text_temperature": 0.8,
-            "audio_temperature": 0.9,
-        }
-        config = PersonaPlexConfig.from_dict(data)
-        assert config.voice_prompt == "NATF2.pt"
-        assert config.text_temperature == 0.8
-        assert config.audio_temperature == 0.9
-
-    def test_transcript_dir_created(self):
-        """Does it create transcript directory on init?"""
-        import tempfile
-
-        with tempfile.TemporaryDirectory() as tmpdir:
-            config = PersonaPlexConfig(
-                transcript_path=tmpdir + "/transcripts/",
-                save_transcripts=True,
-            )
-            assert Path(config.transcript_path).exists()

audio_engine/tests/test_personaplex/test_personaplex_message.py

@@ -1,80 +0,0 @@
-"""Tests for PersonaPlexMessage (Step 2)."""
-
-import pytest
-from pipelines.personaplex import PersonaPlexMessage, MessageType
-
-
-class TestPersonaPlexMessage:
-    """Test WebSocket message encoding and decoding."""
-
-    def test_encode_audio(self):
-        """Can we encode an audio message?"""
-        audio_data = b"fake_opus_audio"
-        msg = PersonaPlexMessage(type=MessageType.AUDIO, data=audio_data)
-        encoded = msg.encode()
-
-        assert encoded[0] == 0x01
-        assert encoded[1:] == audio_data
-
-    def test_encode_text(self):
-        """Can we encode a text message?"""
-        text = "Hello, world!"
-        msg = PersonaPlexMessage(type=MessageType.TEXT, data=text)
-        encoded = msg.encode()
-
-        assert encoded[0] == 0x02
-        assert encoded[1:] == text.encode("utf-8")
-
-    def test_decode_audio(self):
-        """Can we decode an audio message?"""
-        audio_data = b"fake_opus_audio"
-        raw = bytes([0x01]) + audio_data
-
-        msg = PersonaPlexMessage.decode(raw)
-        assert msg.type == MessageType.AUDIO
-        assert msg.data == audio_data
-
-    def test_decode_text(self):
-        """Can we decode a text message?"""
-        text = "Hello, assistant!"
-        raw = bytes([0x02]) + text.encode("utf-8")
-
-        msg = PersonaPlexMessage.decode(raw)
-        assert msg.type == MessageType.TEXT
-        assert msg.data == text
-
-    def test_decode_error(self):
-        """Can we decode an error message?"""
-        error_text = b"Connection timeout"
-        raw = bytes([0x05]) + error_text
-
-        msg = PersonaPlexMessage.decode(raw)
-        assert msg.type == MessageType.ERROR
-        assert msg.data == error_text
-
-    def test_roundtrip_audio(self):
-        """Audio message roundtrip: encode then decode?"""
-        original_data = b"\x00\x01\x02\x03\x04\x05"
-        msg1 = PersonaPlexMessage(type=MessageType.AUDIO, data=original_data)
-
-        encoded = msg1.encode()
-        msg2 = PersonaPlexMessage.decode(encoded)
-
-        assert msg2.type == msg1.type
-        assert msg2.data == original_data
-
-    def test_roundtrip_text(self):
-        """Text message roundtrip: encode then decode?"""
-        original_text = "This is a test message with émojis 🎉"
-        msg1 = PersonaPlexMessage(type=MessageType.TEXT, data=original_text)
-
-        encoded = msg1.encode()
-        msg2 = PersonaPlexMessage.decode(encoded)
-
-        assert msg2.type == msg1.type
-        assert msg2.data == original_text
-
-    def test_decode_too_short(self):
-        """Does decode reject empty message?"""
-        with pytest.raises(ValueError):
-            PersonaPlexMessage.decode(b"")