Real-time Audio Streaming

import asyncio
from orbitalsai.streaming import (
    AsyncStreamingClient,
    StreamingConfig,
    PrintingEventHandlers,
)
async def main():
    # Configure streaming session
    config = StreamingConfig(
        language="english",
        sample_rate=16000,
        chunk_size=8000,      # 500ms at 16kHz
        interim_results=True, # Get partial transcripts
    )
    async with AsyncStreamingClient(api_key="your_api_key_here", config=config) as client:
        await client.connect(PrintingEventHandlers())
        # Stream raw PCM16 mono little-endian data
        with open("audio.pcm", "rb") as f:
            while chunk := f.read(config.bytes_per_chunk):
                await client.send_audio(chunk)
                # Optional: pace to real time
                await asyncio.sleep(config.chunk_duration_ms / 1000.0)
        # Ask server to flush remaining audio and send final transcripts
        await client.flush()
if __name__ == "__main__":
    asyncio.run(main())

import asyncio
import os
from orbitalsai.streaming import (
    AsyncStreamingClient,
    StreamingConfig,
    PrintingEventHandlers,
    AudioConverter,
)
API_KEY = os.getenv("ORBITALSAI_API_KEY", "your_api_key_here")
async def stream_file(file_path: str, language: str = "english") -> None:
    config = StreamingConfig(
        language=language,
        sample_rate=16000,
        chunk_size=8000,
        interim_results=True,
    )
    # Load and convert audio file to PCM16 at 16kHz
    audio_bytes, _ = AudioConverter.from_file(
        file_path,
        target_sample_rate=16000,
    )
    # Split into 500ms chunks
    chunks = AudioConverter.split_chunks(audio_bytes, chunk_size=config.chunk_size)
    async with AsyncStreamingClient(api_key=API_KEY, config=config) as client:
        await client.connect(PrintingEventHandlers())
        for chunk in chunks:
            await client.send_audio(chunk)
            await asyncio.sleep(config.chunk_duration_ms / 1000.0)
        await client.flush()
if __name__ == "__main__":
    asyncio.run(stream_file("speech.mp3", language="english"))

import asyncio
import os
import sys
import numpy as np
import sounddevice as sd
from orbitalsai.streaming import (
    AsyncStreamingClient,
    StreamingConfig,
    PrintingEventHandlers,
)
API_KEY = os.getenv("ORBITALSAI_API_KEY", "your_api_key_here")
async def stream_microphone(
    language: str = "english",
    duration: int = 30,
    device: int | None = None,
) -> None:
    sample_rate = 16000
    blocksize = 8000  # 500ms chunks
    config = StreamingConfig(
        language=language,
        sample_rate=sample_rate,
        chunk_size=blocksize,
        interim_results=True,
    )
    audio_queue: asyncio.Queue[bytes] = asyncio.Queue()
    # Called in a separate thread by sounddevice
    def audio_callback(indata, frames, time_info, status) -> None:
        if status:
            print(f"Audio status: {status}", file=sys.stderr)
        audio_queue.put_nowait(indata.tobytes())
    async with AsyncStreamingClient(api_key=API_KEY, config=config) as client:
        await client.connect(PrintingEventHandlers(show_partials=True))
        with sd.InputStream(
            samplerate=sample_rate,
            channels=1,
            dtype="int16",
            blocksize=blocksize,
            device=device,
            callback=audio_callback,
        ):
            end_time = asyncio.get_event_loop().time() + duration
            while asyncio.get_event_loop().time() < end_time:
                try:
                    audio_data = await asyncio.wait_for(audio_queue.get(), timeout=1.0)
                except asyncio.TimeoutError:
                    continue
                await client.send_audio(audio_data)
        # Flush remaining audio and wait for final transcripts
        await client.flush()
        await asyncio.sleep(2.0)
if __name__ == "__main__":
    asyncio.run(stream_microphone(duration=30))

from orbitalsai.streaming import StreamingConfig
config = StreamingConfig(
    # Audio
    sample_rate=16000,        # 8000–48000 Hz (16kHz recommended)
    chunk_size=8000,          # Samples per chunk (~500ms at 16kHz)
    encoding="pcm_s16le",     # PCM16 mono little-endian
    # Language
    language="english",       # english, hausa, igbo, yoruba
    auto_detect_language=False,
    # Connection & retries
    max_retries=5,
    retry_delay=1.0,          # Initial retry delay (seconds)
    max_retry_delay=60.0,
    keepalive_interval=15.0,  # WebSocket ping interval
    connection_timeout=30.0,  # Connection timeout (seconds)
    # Processing
    interim_results=True,     # Receive partial transcripts
    auto_flush=True,          # Auto-flush on silence
)

import asyncio
from orbitalsai.streaming import (
    AsyncStreamingClient,
    StreamingEventHandlers,
)
from orbitalsai.streaming.exceptions import (
    ConnectionError,
    AuthenticationError,
    InsufficientCreditsError,
    ReconnectionFailedError,
    SessionClosedError,
)
class MyHandlers(StreamingEventHandlers):
    def on_error(self, error: Exception) -> None:
        if isinstance(error, AuthenticationError):
            print("Invalid API key – check your ORBITALSAI_API_KEY.")
        elif isinstance(error, InsufficientCreditsError):
            print("Credits exhausted – please top up your account.")
        elif isinstance(error, ReconnectionFailedError):
            print(f"Failed to reconnect after {error.attempts} attempts.")
        else:
            print(f"Streaming error: {error}")
async def main() -> None:
    try:
        async with AsyncStreamingClient(api_key="your_api_key_here") as client:
            await client.connect(MyHandlers())
            # ... send audio with client.send_audio(...)
            await client.flush()
    except ConnectionError as e:
        print(f"Connection failed: {e}")
    except SessionClosedError:
        print("Session was closed; stop sending audio.")
if __name__ == "__main__":
    asyncio.run(main())