bhashini-client-sdk 0.2.2__tar.gz → 0.2.3__tar.gz

{bhashini_client_sdk-0.2.2/bhashini_client_sdk.egg-info → bhashini_client_sdk-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bhashini-client-sdk
-Version: 0.2.2
+Version: 0.2.3
 Summary: Python SDK for Bhashini inference APIs with unified support for ASR, NMT, TTS, OCR, NER, speaker services, normalization, and image-language workflows.
 Home-page: https://github.com/bhashini-dibd/Bhashini-client-python-library.git
 Author: Nidhi Jha
@@ -25,6 +25,7 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests>=2.25.0
+Requires-Dist: websockets>=12.0
 Requires-Dist: openpyxl>=3.1.0
 Dynamic: author
 Dynamic: classifier

{bhashini_client_sdk-0.2.2 → bhashini_client_sdk-0.2.3}/bhashini_client/core.py

@@ -45,6 +45,15 @@ class BhashiniClient:
     def asr(self, audio_input, source_lang: str):
         return self.asr_service.transcribe(audio_input, source_lang)
 
+    def asr_streaming_config(self, source_lang: str, **kwargs):
+        return self.asr_service.get_streaming_config(source_lang, **kwargs)
+
+    async def asr_stream(self, audio_chunks, source_lang: str, **kwargs):
+        return await self.asr_service.stream_transcribe(audio_chunks, source_lang, **kwargs)
+
+    def asr_stream_sync(self, audio_chunks, source_lang: str, **kwargs):
+        return self.asr_service.stream_transcribe_sync(audio_chunks, source_lang, **kwargs)
+
     def nmt(self, text: str, source_lang: str, target_lang: str):
         return self.nmt_service.translate(text, source_lang, target_lang)
 

{bhashini_client_sdk-0.2.2 → bhashini_client_sdk-0.2.3}/bhashini_client/services/asr_service.py

@@ -1,5 +1,8 @@
+import asyncio
+
 from ..models_info import get_available_models, validate_model_request
 from .audio_input_utils import preprocess_audio_or_uri_input
+from .asr_streaming_client import ASRStreamingClient
 from .service_utils import api_error, input_error, is_error_response
 
 
@@ -23,6 +26,95 @@ class ASRService:
     def get_supported_models(self, language=None):
         return get_available_models("asr", language=language)
 
+    def get_streaming_config(
+        self,
+        source_lang: str,
+        *,
+        service_id: str = None,
+        post_processors=None,
+        interim_results=True,
+    ):
+        streaming_client = self._get_streaming_client(source_lang=source_lang, service_id=service_id)
+        return streaming_client.get_start_config(
+            source_lang=source_lang,
+            service_id=service_id,
+            post_processors=post_processors,
+            interim_results=interim_results,
+        )
+
+    async def stream_transcribe(
+        self,
+        audio_chunks,
+        source_lang: str,
+        *,
+        service_id: str = None,
+        post_processors=None,
+        interim_results=True,
+        receive_timeout=5,
+        chunk_delay_seconds=0,
+        return_details=False,
+        audio_sample_format="int16",
+    ):
+        streaming_client = self._get_streaming_client(source_lang=source_lang, service_id=service_id)
+        return await streaming_client.transcribe_audio_chunks(
+            audio_chunks,
+            source_lang=source_lang,
+            service_id=service_id,
+            post_processors=post_processors,
+            interim_results=interim_results,
+            receive_timeout=receive_timeout,
+            chunk_delay_seconds=chunk_delay_seconds,
+            return_details=return_details,
+            audio_sample_format=audio_sample_format,
+        )
+
+    def stream_transcribe_sync(
+        self,
+        audio_chunks,
+        source_lang: str,
+        *,
+        service_id: str = None,
+        post_processors=None,
+        interim_results=True,
+        receive_timeout=5,
+        chunk_delay_seconds=0,
+        return_details=False,
+        audio_sample_format="int16",
+    ):
+        try:
+            asyncio.get_running_loop()
+        except RuntimeError:
+            return asyncio.run(
+                self.stream_transcribe(
+                    audio_chunks,
+                    source_lang,
+                    service_id=service_id,
+                    post_processors=post_processors,
+                    interim_results=interim_results,
+                    receive_timeout=receive_timeout,
+                    chunk_delay_seconds=chunk_delay_seconds,
+                    return_details=return_details,
+                    audio_sample_format=audio_sample_format,
+                )
+            )
+        return input_error("stream_transcribe_sync cannot be used inside a running event loop. Use await stream_transcribe(...) instead.")
+
+    async def stream_microphone(
+        self,
+        source_lang: str,
+        *,
+        service_id: str = None,
+        post_processors=None,
+        interim_results=True,
+    ):
+        streaming_client = self._get_streaming_client(source_lang=source_lang, service_id=service_id)
+        return await streaming_client.transcribe_microphone(
+            source_lang=source_lang,
+            service_id=service_id,
+            post_processors=post_processors,
+            interim_results=interim_results,
+        )
+
     def transcribe(
         self,
         input_data,
@@ -217,6 +309,14 @@ class ASRService:
             return "ai4bharat/conformer-multilingual-indo_aryan-gpu--t4"
         return "bhashini/ai4bharat/conformer-multilingual-asr"
 
+    def _get_streaming_client(self, *, source_lang: str, service_id: str = None):
+        api_key = getattr(self.handler, "api_key", None)
+        return ASRStreamingClient(
+            api_key=api_key,
+            source_lang=source_lang,
+            service_id=service_id or "bhashini/ai4b/indic-conformer/grpc",
+        )
+
     def postprocess(self, response):
         try:
             return (

bhashini_client_sdk-0.2.3/bhashini_client/services/asr_streaming_client.py

@@ -0,0 +1,350 @@
+import asyncio
+import audioop
+from array import array
+import inspect
+import json
+from urllib.parse import quote
+
+from ..config import API_KEY
+from .service_utils import api_error, input_error
+
+
+DEFAULT_ASR_STREAM_URL = "wss://dhruva-api.bhashini.gov.in/ws/v1/asr/stream"
+DEFAULT_STREAMING_SERVICE_ID = "bhashini/ai4b/indic-conformer/grpc"
+DEFAULT_SAMPLE_RATE = 16000
+DEFAULT_CHUNK_DURATION_MS = 200
+VALID_AUDIO_SAMPLE_FORMATS = {"int16", "float32", "raw"}
+
+
+def int16_pcm_to_float32_bytes(audio_chunk):
+    samples = array("h")
+    samples.frombytes(bytes(audio_chunk))
+    scale = 32768.0
+    return array("f", (max(-1.0, min(1.0, sample / scale)) for sample in samples)).tobytes()
+
+
+def float_samples_to_bytes(audio_chunk):
+    if isinstance(audio_chunk, (bytes, bytearray)):
+        return bytes(audio_chunk)
+    return array("f", audio_chunk).tobytes()
+
+
+class VADProcessor:
+    def __init__(
+        self,
+        *,
+        speech_start_rms=0.020,
+        speech_end_rms=0.010,
+        min_speech_ms=200,
+        min_pause_ms=800,
+        chunk_duration_ms=DEFAULT_CHUNK_DURATION_MS,
+    ):
+        self.speech_start_rms = speech_start_rms
+        self.speech_end_rms = speech_end_rms
+        self.min_speech_ms = min_speech_ms
+        self.min_pause_ms = min_pause_ms
+        self.chunk_duration_ms = chunk_duration_ms
+        self.is_speaking = False
+        self.speech_run_ms = 0
+        self.silence_run_ms = 0
+
+    def process_chunk(self, audio_chunk):
+        if not audio_chunk:
+            return "IDLE"
+        rms = audioop.rms(audio_chunk, 2) / 32768.0
+        if not self.is_speaking:
+            if rms > self.speech_start_rms:
+                self.speech_run_ms += self.chunk_duration_ms
+                if self.speech_run_ms >= self.min_speech_ms:
+                    self.is_speaking = True
+                    self.speech_run_ms = 0
+                    return "START"
+            else:
+                self.speech_run_ms = 0
+        else:
+            if rms < self.speech_end_rms:
+                self.silence_run_ms += self.chunk_duration_ms
+                if self.silence_run_ms >= self.min_pause_ms:
+                    self.is_speaking = False
+                    self.silence_run_ms = 0
+                    return "STOP"
+            else:
+                self.silence_run_ms = 0
+        return "CONTINUE" if self.is_speaking else "IDLE"
+
+
+class ASRStreamingClient:
+    def __init__(
+        self,
+        *,
+        api_key=None,
+        websocket_url=DEFAULT_ASR_STREAM_URL,
+        service_id=DEFAULT_STREAMING_SERVICE_ID,
+        source_lang="hi",
+        sample_rate=DEFAULT_SAMPLE_RATE,
+        chunk_duration_ms=DEFAULT_CHUNK_DURATION_MS,
+    ):
+        self.api_key = (api_key or API_KEY).strip()
+        self.websocket_url = websocket_url
+        self.service_id = service_id
+        self.source_lang = source_lang
+        self.sample_rate = sample_rate
+        self.chunk_duration_ms = chunk_duration_ms
+
+    def get_websocket_url(self):
+        if not self.api_key:
+            return input_error("BHASHINI_API_KEY is missing. Please set it before using ASR streaming.")
+        return f"{self.websocket_url}?api_key={quote(self.api_key)}"
+
+    def get_start_config(
+        self,
+        *,
+        source_lang=None,
+        service_id=None,
+        audio_format="pcm",
+        encoding="raw",
+        sampling_rate=None,
+        post_processors=None,
+        interim_results=True,
+        end_of_stream_policy="client_signal",
+        profanity_filter=True,
+    ):
+        resolved_source_lang = (source_lang or self.source_lang or "").strip().lower()
+        if not resolved_source_lang:
+            return input_error("Source language is missing. Please provide a valid ASR source language code.")
+        resolved_sampling_rate = sampling_rate or self.sample_rate
+        if resolved_sampling_rate != DEFAULT_SAMPLE_RATE:
+            return input_error("ASR streaming supports only 16000 Hz PCM audio chunks.")
+        return {
+            "type": "start",
+            "controlConfig": {"dataTracking": False},
+            "config": {
+                "serviceId": service_id or self.service_id,
+                "language": {"sourceLanguage": resolved_source_lang},
+                "audioFormat": audio_format,
+                "encoding": encoding,
+                "samplingRate": resolved_sampling_rate,
+                "transcriptionFormat": {"value": "transcript"},
+                "profanityFilter": profanity_filter,
+                "postProcessors": post_processors or ["itn", "punctuation"],
+            },
+            "streamingConfig": {
+                "chunkDurationMs": self.chunk_duration_ms,
+                "interimResults": interim_results,
+                "endOfStreamPolicy": end_of_stream_policy,
+            },
+        }
+
+    async def transcribe_audio_chunks(
+        self,
+        audio_chunks,
+        *,
+        source_lang=None,
+        service_id=None,
+        post_processors=None,
+        interim_results=True,
+        receive_timeout=5,
+        chunk_delay_seconds=0,
+        return_details=False,
+        wait_for_ready=True,
+        audio_sample_format="int16",
+    ):
+        try:
+            import websockets
+        except ImportError:
+            return input_error("The 'websockets' package is required for ASR streaming. Install it before using this feature.")
+
+        if audio_sample_format not in VALID_AUDIO_SAMPLE_FORMATS:
+            return input_error("audio_sample_format must be one of: int16, float32, raw.")
+
+        websocket_url = self.get_websocket_url()
+        if isinstance(websocket_url, str) and websocket_url.startswith("Input Error:"):
+            return websocket_url
+
+        start_config = self.get_start_config(
+            source_lang=source_lang,
+            service_id=service_id,
+            post_processors=post_processors,
+            interim_results=interim_results,
+        )
+        if isinstance(start_config, str) and start_config.startswith("Input Error:"):
+            return start_config
+
+        transcripts = []
+        messages = []
+
+        async def wait_until_ready(websocket):
+            while True:
+                message = await asyncio.wait_for(websocket.recv(), timeout=receive_timeout)
+                response = json.loads(message)
+                messages.append(response)
+                if response.get("type") == "ready":
+                    return None
+                if response.get("type") == "error":
+                    return response
+
+        async def receive_transcripts(websocket):
+            try:
+                while True:
+                    message = await websocket.recv()
+                    response = json.loads(message)
+                    messages.append(response)
+                    if response.get("type") != "transcript":
+                        continue
+                    text = (response.get("output") or [{}])[0].get("source")
+                    if text:
+                        transcripts.append(
+                            {
+                                "source": text,
+                                "isFinal": response.get("isFinal", False),
+                                "raw": response,
+                            }
+                        )
+                    if response.get("isFinal"):
+                        break
+            except Exception:
+                # Normal WebSocket closure is expected after the service finishes a stream.
+                return
+
+        def prepare_chunk(chunk):
+            if not isinstance(chunk, (bytes, bytearray)) or not chunk:
+                if audio_sample_format == "float32" and chunk:
+                    return float_samples_to_bytes(chunk)
+                return None
+            if audio_sample_format == "int16":
+                return int16_pcm_to_float32_bytes(chunk)
+            if audio_sample_format == "float32":
+                return float_samples_to_bytes(chunk)
+            return bytes(chunk)
+
+        async def send_chunk(websocket, chunk):
+            prepared_chunk = prepare_chunk(chunk)
+            if not prepared_chunk:
+                return
+            await websocket.send(prepared_chunk)
+            if chunk_delay_seconds:
+                await asyncio.sleep(chunk_delay_seconds)
+
+        try:
+            async with websockets.connect(websocket_url) as websocket:
+                await websocket.send(json.dumps(start_config))
+                if wait_for_ready:
+                    early_error = await wait_until_ready(websocket)
+                    if early_error:
+                        if return_details:
+                            return {
+                                "transcript": None,
+                                "messages": messages,
+                                "error": early_error.get("message") or "ASR streaming backend returned an error.",
+                            }
+                        return api_error(early_error.get("message") or "ASR streaming backend returned an error.")
+                receiver_task = asyncio.create_task(receive_transcripts(websocket))
+                if inspect.isasyncgen(audio_chunks):
+                    async for chunk in audio_chunks:
+                        await send_chunk(websocket, chunk)
+                else:
+                    for chunk in audio_chunks:
+                        await send_chunk(websocket, chunk)
+                try:
+                    await websocket.send(json.dumps({"type": "end"}))
+                except Exception:
+                    pass
+                try:
+                    await asyncio.wait_for(receiver_task, timeout=receive_timeout)
+                except asyncio.TimeoutError:
+                    receiver_task.cancel()
+        except Exception as exc:
+            error_messages = [message for message in messages if message.get("type") == "error"]
+            if error_messages:
+                backend_message = error_messages[-1].get("message") or "ASR streaming backend returned an error."
+                if return_details:
+                    return {
+                        "transcript": None,
+                        "messages": messages,
+                        "error": backend_message,
+                    }
+                return api_error(backend_message)
+            if return_details:
+                return {
+                    "transcript": None,
+                    "messages": messages,
+                    "error": "ASR streaming service did not return a valid response.",
+                    "exception": f"{type(exc).__name__}: {exc}",
+                }
+            return api_error("ASR streaming service did not return a valid response.")
+
+        error_messages = [message for message in messages if message.get("type") == "error"]
+        if error_messages:
+            backend_message = error_messages[-1].get("message") or "ASR streaming backend returned an error."
+            if return_details:
+                return {
+                    "transcript": None,
+                    "messages": messages,
+                    "error": backend_message,
+                }
+            return api_error(backend_message)
+        if not transcripts:
+            if return_details:
+                return {
+                    "transcript": None,
+                    "messages": messages,
+                    "error": "ASR streaming service returned an empty transcription.",
+                }
+            return api_error("ASR streaming service returned an empty transcription.")
+        final_transcripts = [item for item in transcripts if item["isFinal"]]
+        transcript = (final_transcripts or transcripts)[-1]["source"]
+        if return_details:
+            return {
+                "transcript": transcript,
+                "messages": messages,
+                "final": bool(final_transcripts),
+            }
+        return transcript
+
+    async def transcribe_microphone(
+        self,
+        *,
+        source_lang=None,
+        service_id=None,
+        post_processors=None,
+        interim_results=True,
+    ):
+        try:
+            import pyaudio
+        except ImportError:
+            return input_error("The 'pyaudio' package is required for microphone ASR streaming.")
+
+        vad = VADProcessor(chunk_duration_ms=self.chunk_duration_ms)
+        samples_per_chunk = int(self.sample_rate * self.chunk_duration_ms / 1000)
+        audio = pyaudio.PyAudio()
+        stream = audio.open(
+            format=pyaudio.paInt16,
+            channels=1,
+            rate=self.sample_rate,
+            input=True,
+            frames_per_buffer=samples_per_chunk,
+        )
+
+        async def chunk_generator():
+            try:
+                while True:
+                    chunk = stream.read(samples_per_chunk, exception_on_overflow=False)
+                    state = vad.process_chunk(chunk)
+                    if state in {"START", "CONTINUE"}:
+                        yield chunk
+                    if state == "STOP":
+                        break
+                    await asyncio.sleep(0.01)
+            finally:
+                stream.stop_stream()
+                stream.close()
+                audio.terminate()
+
+        return await self.transcribe_audio_chunks(
+            chunk_generator(),
+            source_lang=source_lang,
+            service_id=service_id,
+            post_processors=post_processors,
+            interim_results=interim_results,
+            chunk_delay_seconds=0,
+        )

{bhashini_client_sdk-0.2.2 → bhashini_client_sdk-0.2.3}/bhashini_client/services/audio_input_utils.py

@@ -189,7 +189,7 @@ def _inspect_and_prepare_wav(
             frame_count = audio_stream.getnframes()
             channels = audio_stream.getnchannels()
             sample_width = audio_stream.getsampwidth()
-            frame_rate = audio_stream.getframerate()
+            frame_rate = audio_stream.getframerate() 
             if frame_count == 0:
                 return input_error(
                     "The audio file does not contain any frames. Please provide an audio file with speech."

{bhashini_client_sdk-0.2.2 → bhashini_client_sdk-0.2.3}/bhashini_client/utils/request_handler.py

@@ -9,6 +9,7 @@ from ..config import API_KEY, BASE_URL, DEFAULT_HEADERS, DEFAULT_TIMEOUT
 class RequestHandler:
     def __init__(self, api_key: Optional[str] = None):
         auth_token = (api_key or API_KEY).strip()
+        self.api_key = auth_token
         self.headers = {**DEFAULT_HEADERS, "Authorization": auth_token}
 
     def post(self, payload: dict, url: Optional[str] = None, headers: Optional[dict] = None):

{bhashini_client_sdk-0.2.2 → bhashini_client_sdk-0.2.3/bhashini_client_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bhashini-client-sdk
-Version: 0.2.2
+Version: 0.2.3
 Summary: Python SDK for Bhashini inference APIs with unified support for ASR, NMT, TTS, OCR, NER, speaker services, normalization, and image-language workflows.
 Home-page: https://github.com/bhashini-dibd/Bhashini-client-python-library.git
 Author: Nidhi Jha
@@ -25,6 +25,7 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests>=2.25.0
+Requires-Dist: websockets>=12.0
 Requires-Dist: openpyxl>=3.1.0
 Dynamic: author
 Dynamic: classifier

{bhashini_client_sdk-0.2.2 → bhashini_client_sdk-0.2.3}/bhashini_client_sdk.egg-info/SOURCES.txt

@@ -11,6 +11,7 @@ bhashini_client/core.py
 bhashini_client/models_info.py
 bhashini_client/services/__init__.py
 bhashini_client/services/asr_service.py
+bhashini_client/services/asr_streaming_client.py
 bhashini_client/services/audio_input_utils.py
 bhashini_client/services/audio_language_detection_service.py
 bhashini_client/services/denoiser_service.py
@@ -36,6 +37,8 @@ bhashini_client_sdk.egg-info/dependency_links.txt
 bhashini_client_sdk.egg-info/requires.txt
 bhashini_client_sdk.egg-info/top_level.txt
 tests/test_asr.py
+tests/test_asr_streaming_live.py
+tests/test_asr_streaming_mic_live.py
 tests/test_audio_input_utils.py
 tests/test_audio_language_detection.py
 tests/test_bhashini_client.py

{bhashini_client_sdk-0.2.2 → bhashini_client_sdk-0.2.3}/bhashini_client_sdk.egg-info/requires.txt

@@ -1,2 +1,3 @@
 requests>=2.25.0
+websockets>=12.0
 openpyxl>=3.1.0

{bhashini_client_sdk-0.2.2 → bhashini_client_sdk-0.2.3}/setup.py

@@ -1,16 +1,16 @@
-from pathlib import Path
-
-from setuptools import find_packages, setup
-
-
-LONG_DESCRIPTION_PATH = Path(__file__).parent / "PYPI_DESCRIPTION.md"
+from pathlib import Path
+
+from setuptools import find_packages, setup
+
+
+LONG_DESCRIPTION_PATH = Path(__file__).parent / "PYPI_DESCRIPTION.md"
 
 
 setup(
-    name="bhashini-client-sdk",
-    version="0.2.2",
-    description="Python SDK for Bhashini inference APIs with unified support for ASR, NMT, TTS, OCR, NER, speaker services, normalization, and image-language workflows.",
-    long_description=LONG_DESCRIPTION_PATH.read_text(encoding="utf-8"),
+    name="bhashini-client-sdk",
+    version="0.2.3",
+    description="Python SDK for Bhashini inference APIs with unified support for ASR, NMT, TTS, OCR, NER, speaker services, normalization, and image-language workflows.",
+    long_description=LONG_DESCRIPTION_PATH.read_text(encoding="utf-8"),
     long_description_content_type="text/markdown",
     author="Nidhi Jha",
     url="https://github.com/bhashini-dibd/Bhashini-client-python-library.git",
@@ -19,6 +19,7 @@ setup(
     include_package_data=True,
     install_requires=[
         "requests>=2.25.0",
+        "websockets>=12.0",
         "openpyxl>=3.1.0",
     ],
     python_requires=">=3.8",

{bhashini_client_sdk-0.2.2 → bhashini_client_sdk-0.2.3}/tests/test_asr.py

@@ -2,6 +2,7 @@ import base64
 import wave
 
 from bhashini_client.services.asr_service import ASRService
+from bhashini_client.services.asr_streaming_client import ASRStreamingClient, int16_pcm_to_float32_bytes
 
 from tests.assertions import INPUT_ERROR, assert_service_output
 from tests.result_logger import log_test_result
@@ -191,3 +192,65 @@ def test_asr_uri_payload_supports_flac():
     assert config["audioFormat"] == "flac"
     assert config["encoding"] == "FLAC"
     assert audio_payload["audioUri"] == "https://example.com/sample.flac"
+
+
+def test_asr_streaming_config_uses_existing_api_key_and_defaults():
+    streaming_client = ASRStreamingClient(api_key="demo-key", source_lang="hi")
+
+    websocket_url = streaming_client.get_websocket_url()
+    start_config = streaming_client.get_start_config()
+
+    assert websocket_url == "wss://dhruva-api.bhashini.gov.in/ws/v1/asr/stream?api_key=demo-key"
+    assert start_config["type"] == "start"
+    assert start_config["controlConfig"]["dataTracking"] is False
+    assert start_config["config"]["serviceId"] == "bhashini/ai4b/indic-conformer/grpc"
+    assert start_config["config"]["language"]["sourceLanguage"] == "hi"
+    assert start_config["config"]["audioFormat"] == "pcm"
+    assert start_config["config"]["encoding"] == "raw"
+    assert start_config["config"]["samplingRate"] == 16000
+    assert start_config["config"]["transcriptionFormat"] == {"value": "transcript"}
+    assert start_config["config"]["profanityFilter"] is True
+    assert start_config["config"]["postProcessors"] == ["itn", "punctuation"]
+    assert start_config["streamingConfig"]["chunkDurationMs"] == 200
+    assert start_config["streamingConfig"]["interimResults"] is True
+
+
+def test_asr_streaming_path_is_explicit_and_does_not_call_http_handler():
+    captured = {}
+
+    class Handler:
+        api_key = "demo-key"
+
+        def post(self, payload):
+            raise AssertionError("HTTP request-response path should not run for explicit streaming calls.")
+
+    class FakeStreamingClient:
+        async def transcribe_audio_chunks(self, audio_chunks, **kwargs):
+            captured["chunks"] = list(audio_chunks)
+            captured["kwargs"] = kwargs
+            return "streaming transcription"
+
+    service = ASRService(Handler())
+    service._get_streaming_client = lambda **kwargs: FakeStreamingClient()
+
+    actual_output = service.stream_transcribe_sync(
+        [b"\x01\x00" * 160],
+        "hi",
+        post_processors=["itn"],
+        receive_timeout=1,
+        audio_sample_format="int16",
+    )
+
+    assert actual_output == "streaming transcription"
+    assert captured["chunks"] == [b"\x01\x00" * 160]
+    assert captured["kwargs"]["source_lang"] == "hi"
+    assert captured["kwargs"]["post_processors"] == ["itn"]
+    assert captured["kwargs"]["receive_timeout"] == 1
+    assert captured["kwargs"]["audio_sample_format"] == "int16"
+
+
+def test_asr_streaming_converts_int16_chunks_to_float32_wire_bytes():
+    streaming_client = ASRStreamingClient(api_key="demo-key", source_lang="hi")
+    converted = int16_pcm_to_float32_bytes(b"\x00\x00\x00@\x00\xc0")
+
+    assert len(converted) == 12

bhashini_client_sdk-0.2.3/tests/test_asr_streaming_live.py

@@ -0,0 +1,73 @@
+import argparse
+import audioop
+import json
+import wave
+
+from bhashini_client import BhashiniClient
+from bhashini_client.services.asr_streaming_client import VADProcessor
+
+
+def wav_chunks(path, *, sample_rate=16000, chunk_ms=200, vad=False):
+    with wave.open(path, "rb") as audio:
+        channels = audio.getnchannels()
+        sample_width = audio.getsampwidth()
+        frame_rate = audio.getframerate()
+        audio_bytes = audio.readframes(audio.getnframes())
+        if channels == 2:
+            audio_bytes = audioop.tomono(audio_bytes, sample_width, 0.5, 0.5)
+            channels = 1
+        if channels != 1:
+            raise ValueError(f"Streaming ASR expects mono or stereo audio, but received {channels} channels.")
+        if sample_width != 2:
+            audio_bytes = audioop.lin2lin(audio_bytes, sample_width, 2)
+            sample_width = 2
+        if frame_rate != sample_rate:
+            print(f"AUDIO_RESAMPLE: received {frame_rate} Hz, converting to {sample_rate} Hz for ASR streaming.")
+            audio_bytes, _ = audioop.ratecv(audio_bytes, sample_width, channels, frame_rate, sample_rate, None)
+        frames_per_chunk = int(sample_rate * chunk_ms / 1000)
+        bytes_per_chunk = frames_per_chunk * sample_width
+        vad_processor = VADProcessor(chunk_duration_ms=chunk_ms) if vad else None
+        for index in range(0, len(audio_bytes), bytes_per_chunk):
+            chunk = audio_bytes[index:index + bytes_per_chunk]
+            if vad_processor:
+                state = vad_processor.process_chunk(chunk)
+                if state not in {"START", "CONTINUE"}:
+                    continue
+            yield chunk
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Run a real ASR streaming test with a local WAV file.")
+    parser.add_argument("--audio", required=True, help="Path to a 16 kHz mono 16-bit PCM WAV file.")
+    parser.add_argument("--lang", default="hi", help="ASR source language code. Default: hi")
+    parser.add_argument("--chunk-ms", type=int, default=200, help="Chunk duration in milliseconds. Default: 200")
+    parser.add_argument("--timeout", type=int, default=10, help="Receive timeout after sending audio. Default: 10")
+    parser.add_argument("--details", action="store_true", help="Print raw backend messages along with the final transcript.")
+    parser.add_argument("--vad", action="store_true", help="Send only speech chunks using the same VAD style as the mentor script.")
+    parser.add_argument("--service-id", default=None, help="Optional ASR streaming service id override.")
+    parser.add_argument("--no-postprocessors", action="store_true", help="Send streaming audio without ITN/punctuation postprocessors.")
+    parser.add_argument("--audio-sample-format", default="int16", choices=["int16", "float32", "raw"], help="Input chunk format before SDK sends it. Default converts int16 WAV chunks to mentor-compatible float32 stream bytes.")
+    args = parser.parse_args()
+
+    client = BhashiniClient()
+    chunks = list(wav_chunks(args.audio, chunk_ms=args.chunk_ms, vad=args.vad))
+    print(f"STREAMING_CHUNKS_SENT: {len(chunks)}")
+    result = client.asr_stream_sync(
+        chunks,
+        args.lang,
+        service_id=args.service_id,
+        post_processors=[] if args.no_postprocessors else ["itn", "punctuation"],
+        receive_timeout=args.timeout,
+        chunk_delay_seconds=args.chunk_ms / 1000.0,
+        return_details=args.details,
+        audio_sample_format=args.audio_sample_format,
+    )
+    print("ASR_STREAMING_RESULT:")
+    if isinstance(result, (dict, list)):
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+    else:
+        print(result)
+
+
+if __name__ == "__main__":
+    main()

bhashini_client_sdk-0.2.3/tests/test_asr_streaming_mic_live.py

@@ -0,0 +1,118 @@
+import argparse
+import asyncio
+import json
+
+from bhashini_client.services.asr_streaming_client import (
+    ASRStreamingClient,
+    VADProcessor,
+    int16_pcm_to_float32_bytes,
+)
+
+
+async def run_mic_stream(args):
+    try:
+        import pyaudio
+        import websockets
+    except ImportError as exc:
+        missing = getattr(exc, "name", None) or str(exc)
+        print(f"Missing dependency: {missing}")
+        print("Install microphone dependencies first, for example: python -m pip install pyaudio websockets")
+        return
+
+    streaming_client = ASRStreamingClient(source_lang=args.lang, chunk_duration_ms=args.chunk_ms)
+    websocket_url = streaming_client.get_websocket_url()
+    if isinstance(websocket_url, str) and websocket_url.startswith("Input Error:"):
+        print(websocket_url)
+        return
+
+    start_config = streaming_client.get_start_config(
+        source_lang=args.lang,
+        post_processors=[] if args.no_postprocessors else ["itn", "punctuation"],
+    )
+    if isinstance(start_config, str) and start_config.startswith("Input Error:"):
+        print(start_config)
+        return
+
+    samples_per_chunk = int(streaming_client.sample_rate * args.chunk_ms / 1000)
+    vad = VADProcessor(chunk_duration_ms=args.chunk_ms) if args.vad else None
+    audio = pyaudio.PyAudio()
+    stream = audio.open(
+        format=pyaudio.paInt16,
+        channels=1,
+        rate=streaming_client.sample_rate,
+        input=True,
+        frames_per_buffer=samples_per_chunk,    )
+
+    chunks_sent = 0
+    stop_event = asyncio.Event()
+
+    print("MIC_STREAMING_STARTED")
+    print("Speak now. Press Ctrl+C to stop.")
+
+    async def receive_messages(websocket):
+        nonlocal stop_event
+        async for message in websocket:
+            response = json.loads(message)
+            if response.get("type") == "ready":
+                print(f"READY session={response.get('sessionId')} model={response.get('modelName')}")
+            elif response.get("type") == "transcript":
+                text = (response.get("output") or [{}])[0].get("source", "")
+                label = "FINAL" if response.get("isFinal") else "INTERIM"
+                print(f"{label}: {text}")
+                if response.get("isFinal"):
+                    stop_event.set()
+            elif response.get("type") == "error":
+                print("ERROR:")
+                print(response.get("message") or response)
+                stop_event.set()
+            elif response.get("type") == "end":
+                print("END")
+                stop_event.set()
+
+    try:
+        async with websockets.connect(websocket_url) as websocket:
+            await websocket.send(json.dumps(start_config))
+            receiver_task = asyncio.create_task(receive_messages(websocket))
+            while not stop_event.is_set():
+                chunk = stream.read(samples_per_chunk, exception_on_overflow=False)
+                if vad:
+                    state = vad.process_chunk(chunk)
+                    if state not in {"START", "CONTINUE"}:
+                        await asyncio.sleep(args.chunk_ms / 1000)
+                        continue
+                await websocket.send(int16_pcm_to_float32_bytes(chunk))
+                await asyncio.sleep(args.chunk_ms / 1000)
+                chunks_sent += 1
+                if args.max_seconds and chunks_sent * args.chunk_ms >= args.max_seconds * 1000:
+                    stop_event.set()
+            try:
+                await websocket.send(json.dumps({"type": "end"}))
+            except Exception:
+                pass
+            try:
+                await asyncio.wait_for(receiver_task, timeout=args.timeout)
+            except asyncio.TimeoutError:
+                receiver_task.cancel()
+    except KeyboardInterrupt:
+        print("Stopped by user.")
+    finally:
+        stream.stop_stream()
+        stream.close()
+        audio.terminate()
+        print(f"MIC_CHUNKS_SENT: {chunks_sent}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Live microphone ASR streaming demo.")
+    parser.add_argument("--lang", default="hi", help="ASR source language code. Default: hi")
+    parser.add_argument("--chunk-ms", type=int, default=200, help="Chunk duration in milliseconds. Default: 200")
+    parser.add_argument("--timeout", type=int, default=10, help="Wait time for final backend messages. Default: 10")
+    parser.add_argument("--max-seconds", type=int, default=8, help="Maximum seconds to record. Default: 8")
+    parser.add_argument("--vad", action="store_true", help="Send only speech chunks using VAD.")
+    parser.add_argument("--no-postprocessors", action="store_true", help="Disable ITN/punctuation postprocessors.")
+    args = parser.parse_args()
+    asyncio.run(run_mic_stream(args))
+
+
+if __name__ == "__main__":
+    main()