bhashini-client-sdk 0.1.3__tar.gz

bhashini_client_sdk-0.1.3/LICENSE

@@ -0,0 +1,13 @@
+
+---
+
+## ⚙️ 4. `LICENSE`
+
+Use MIT License (safe and common):
+
+```text
+MIT License
+
+Copyright (c) 2025 BHASHINI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy...

bhashini_client_sdk-0.1.3/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: bhashini-client-sdk
+Version: 0.1.3
+Summary: Python SDK for Bhashini APIs (ASR, NMT, TTS, Transliteration, Language Detection)
+Home-page: https://github.com/Nidhi18-git/bhashini-client.git
+Author: Nidhi Jha
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: openpyxl
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# bhashini-client-sdk
+
+A simple Python SDK for interacting with [Bhashini](https://bhashini.gov.in/) APIs.
+
+---
+
+## 🚀 Features
+
+* ASR (Automatic Speech Recognition)
+* NMT (Machine Translation)
+* TTS (Text-to-Speech)
+* Language Detection
+* Transliteration
+* ASR + NMT pipeline (Speech → Translation)
+
+---
+
+## 📦 Installation
+
+```bash
+pip install bhashini-client-sdk
+```
+
+---
+
+## 🔑 Setup
+
+Set your Bhashini API key:
+
+```bash
+# Windows PowerShell
+$env:BHASHINI_API_KEY="your_api_key"
+```
+
+---
+
+## 🧪 Example Usage
+
+```python
+from bhashini_client.core import BhashiniClient
+
+client = BhashiniClient()
+
+# Language Detection
+print(client.detect_language("Hello"))
+
+# Translation
+print(client.nmt("Hello", "en", "hi"))
+
+# Transliteration
+print(client.transliterate("namaste", "en", "hi"))
+
+# Text-to-Speech
+client.tts("Hello", "en")
+
+# ASR (Speech to Text)
+print(client.asr("sample.wav", "hi"))
+
+# ASR + NMT
+print(client.asr_nmt("sample.wav", "hi", "en"))
+```
+
+---
+
+## 🔊 TTS Output
+
+TTS generates an audio file:
+
+```
+output.wav
+```
+
+You can play it locally after generation.
+
+---
+
+## 📊 Testing
+
+* Includes edge case testing
+* Excel file (`test_results.xlsx`) generated for tracking results
+
+---
+
+## ⚙️ Requirements
+
+* Python 3.7+
+* requests
+* openpyxl
+
+---
+
+## 📌 Notes
+
+* API key is required for all services
+* Do NOT hardcode API key in code
+* Uses direct `serviceId` (no dynamic mapping)
+
+---
+
+## 👩‍💻 Author
+
+Nidhi Jha
+

bhashini_client_sdk-0.1.3/README.md

@@ -0,0 +1,103 @@
+# bhashini-client-sdk
+
+A simple Python SDK for interacting with [Bhashini](https://bhashini.gov.in/) APIs.
+
+---
+
+## 🚀 Features
+
+* ASR (Automatic Speech Recognition)
+* NMT (Machine Translation)
+* TTS (Text-to-Speech)
+* Language Detection
+* Transliteration
+* ASR + NMT pipeline (Speech → Translation)
+
+---
+
+## 📦 Installation
+
+```bash
+pip install bhashini-client-sdk
+```
+
+---
+
+## 🔑 Setup
+
+Set your Bhashini API key:
+
+```bash
+# Windows PowerShell
+$env:BHASHINI_API_KEY="your_api_key"
+```
+
+---
+
+## 🧪 Example Usage
+
+```python
+from bhashini_client.core import BhashiniClient
+
+client = BhashiniClient()
+
+# Language Detection
+print(client.detect_language("Hello"))
+
+# Translation
+print(client.nmt("Hello", "en", "hi"))
+
+# Transliteration
+print(client.transliterate("namaste", "en", "hi"))
+
+# Text-to-Speech
+client.tts("Hello", "en")
+
+# ASR (Speech to Text)
+print(client.asr("sample.wav", "hi"))
+
+# ASR + NMT
+print(client.asr_nmt("sample.wav", "hi", "en"))
+```
+
+---
+
+## 🔊 TTS Output
+
+TTS generates an audio file:
+
+```
+output.wav
+```
+
+You can play it locally after generation.
+
+---
+
+## 📊 Testing
+
+* Includes edge case testing
+* Excel file (`test_results.xlsx`) generated for tracking results
+
+---
+
+## ⚙️ Requirements
+
+* Python 3.7+
+* requests
+* openpyxl
+
+---
+
+## 📌 Notes
+
+* API key is required for all services
+* Do NOT hardcode API key in code
+* Uses direct `serviceId` (no dynamic mapping)
+
+---
+
+## 👩‍💻 Author
+
+Nidhi Jha
+

bhashini_client_sdk-0.1.3/bhashini_client/__init__.py

@@ -0,0 +1,3 @@
+from .core import BhashiniClient
+
+__all__ = ["BhashiniClient"]

bhashini_client_sdk-0.1.3/bhashini_client/config.py

@@ -0,0 +1,10 @@
+import os
+
+BASE_URL = "https://dhruva-api.bhashini.gov.in/services/inference/pipeline"
+API_KEY = os.getenv("BHASHINI_API_KEY", "").strip()
+DEFAULT_TIMEOUT = 30
+DEFAULT_HEADERS = {
+    "Content-Type": "application/json",
+    "Accept": "application/json",
+    "User-Agent": "bhashini-python-client",
+}

bhashini_client_sdk-0.1.3/bhashini_client/core.py

@@ -0,0 +1,40 @@
+from typing import Optional
+
+from .config import API_KEY
+from .services.asr_service import ASRService
+from .services.language_detection_service import LanguageDetectionService
+from .services.nmt_service import NMTService
+from .services.transliteration_service import TransliterationService
+from .services.tts_service import TTSService
+from .utils.request_handler import RequestHandler
+
+
+class BhashiniClient:
+    def __init__(self, api_key: Optional[str] = None):
+        self.handler = RequestHandler(api_key or API_KEY)
+        self.asr_service = ASRService(self.handler)
+        self.nmt_service = NMTService(self.handler)
+        self.tts_service = TTSService(self.handler)
+        self.language_detection_service = LanguageDetectionService(self.handler)
+        self.transliteration_service = TransliterationService(self.handler)
+
+    def asr(self, audio_input, source_lang: str):
+        return self.asr_service.transcribe(audio_input, source_lang)
+
+    def nmt(self, text: str, source_lang: str, target_lang: str):
+        return self.nmt_service.translate(text, source_lang, target_lang)
+
+    def tts(self, text: str, source_lang: str, gender: str = "female", output_file: str = "output.wav"):
+        return self.tts_service.synthesize(text, source_lang, gender, output_file)
+
+    def language_detection(self, text: str):
+        return self.language_detection_service.detect(text)
+
+    def transliteration(self, text: str, source_lang: str, target_lang: str):
+        return self.transliteration_service.transliterate(text, source_lang, target_lang)
+
+    def speech_translate(self, audio_input, source_lang: str, target_lang: str):
+        transcription = self.asr(audio_input, source_lang)
+        if transcription in {"Invalid input", "API Error"}:
+            return transcription
+        return self.nmt(transcription, source_lang, target_lang)

bhashini_client_sdk-0.1.3/bhashini_client/services/asr_service.py

@@ -0,0 +1,105 @@
+import base64
+import os
+
+
+class ASRService:
+    def __init__(self, handler):
+        self.handler = handler
+
+    def preprocess(self, input_data):
+        if input_data is None:
+            return "Invalid input"
+        if isinstance(input_data, bytes):
+            if not input_data:
+                return "Invalid input"
+            return base64.b64encode(input_data).decode("utf-8")
+        if not isinstance(input_data, str):
+            return "Invalid input"
+        cleaned_input = input_data.strip()
+        if not cleaned_input:
+            return "Invalid input"
+        if os.path.isfile(cleaned_input):
+            with open(cleaned_input, "rb") as audio_file:
+                return base64.b64encode(audio_file.read()).decode("utf-8")
+        try:
+            base64.b64decode(cleaned_input, validate=True)
+            return cleaned_input
+        except Exception:
+            return "Invalid input"
+
+    def transcribe(self, input_data, source_lang: str):
+        processed_input = self.preprocess(input_data)
+        if processed_input == "Invalid input":
+            return processed_input
+        response = self.handler.post(
+            self._build_payload(
+                processed_input,
+                source_lang,
+                self._get_primary_service_id(source_lang),
+            )
+        )
+        if not response:
+            response = self.handler.post(
+                self._build_payload(
+                    processed_input,
+                    source_lang,
+                    self._get_fallback_service_id(source_lang),
+                )
+            )
+        if not response and source_lang.strip().lower() == "hi":
+            response = self.handler.post(
+                self._build_payload(
+                    processed_input,
+                    source_lang,
+                    "bhashini/ai4bharat/conformer-multilingual-asr",
+                )
+            )
+        if not response:
+            return "API Error"
+        return self.postprocess(response)
+
+    def _build_payload(self, audio_content, source_lang: str, service_id: str):
+        return {
+            "pipelineTasks": [
+                {
+                    "taskType": "asr",
+                    "config": {
+                        "language": {"sourceLanguage": source_lang},
+                        "serviceId": service_id,
+                        "audioFormat": "wav",
+                        "samplingRate": 16000,
+                    },
+                }
+            ],
+            "inputData": {
+                "audio": [
+                    {
+                        "audioContent": audio_content,
+                    }
+                ]
+            },
+        }
+
+    def _get_primary_service_id(self, source_lang: str):
+        normalized_lang = source_lang.strip().lower()
+        if normalized_lang == "hi":
+            return "ai4bharat/conformer-hi-gpu--t4"
+        if normalized_lang == "en":
+            return "ai4bharat/whisper-medium-en--gpu--t4"
+        return "bhashini/ai4bharat/conformer-multilingual-asr"
+
+    def _get_fallback_service_id(self, source_lang: str):
+        normalized_lang = source_lang.strip().lower()
+        if normalized_lang == "hi":
+            return "ai4bharat/conformer-multilingual-indo_aryan-gpu--t4"
+        return "bhashini/ai4bharat/conformer-multilingual-asr"
+
+    def postprocess(self, response):
+        try:
+            return (
+                response.get("pipelineResponse", [{}])[0]
+                .get("output", [{}])[0]
+                .get("source", "API Error")
+            ) or "API Error"
+        except Exception:
+            return "API Error"

bhashini_client_sdk-0.1.3/bhashini_client/services/language_detection_service.py

@@ -0,0 +1,41 @@
+class LanguageDetectionService:
+    def __init__(self, handler):
+        self.handler = handler
+
+    def preprocess(self, input_data):
+        if input_data is None or not isinstance(input_data, str):
+            return "Invalid input"
+        cleaned_input = input_data.strip()
+        if not cleaned_input:
+            return "Invalid input"
+        return cleaned_input
+
+    def detect(self, input_data):
+        processed_input = self.preprocess(input_data)
+        if processed_input == "Invalid input":
+            return processed_input
+        payload = {
+            "pipelineTasks": [
+                {
+                    "taskType": "txt-lang-detection",
+                    "config": {
+                        "serviceId": "bhashini/indic-lang-detection-all",
+                    },
+                }
+            ],
+            "inputData": {"input": [{"source": processed_input}]},
+        }
+        response = self.handler.post(payload)
+        if not response:
+            return "API Error"
+        return self.postprocess(response)
+
+    def postprocess(self, response):
+        try:
+            output = response.get("pipelineResponse", [{}])[0].get("output", [{}])[0]
+            predictions = output.get("langPrediction", [])
+            if predictions:
+                return predictions[0].get("langCode", "API Error") or "API Error"
+            return "API Error"
+        except Exception:
+            return "API Error"

bhashini_client_sdk-0.1.3/bhashini_client/services/nmt_service.py

@@ -0,0 +1,77 @@
+class NMTService:
+    def __init__(self, handler):
+        self.handler = handler
+
+    def preprocess(self, input_data):
+        if input_data is None or not isinstance(input_data, str):
+            return "Invalid input"
+        cleaned_input = input_data.strip()
+        if not cleaned_input:
+            return "Invalid input"
+        return cleaned_input
+
+    def translate(self, input_data, source_lang: str, target_lang: str):
+        processed_input = self.preprocess(input_data)
+        if processed_input == "Invalid input":
+            return processed_input
+        response = self.handler.post(
+            self._build_payload(
+                processed_input,
+                source_lang,
+                target_lang,
+                self._get_primary_service_id(source_lang, target_lang),
+            )
+        )
+        if not response:
+            response = self.handler.post(
+                self._build_payload(
+                    processed_input,
+                    source_lang,
+                    target_lang,
+                    self._get_fallback_service_id(source_lang, target_lang),
+                )
+            )
+        if not response:
+            return "API Error"
+        return self.postprocess(response)
+
+    def _build_payload(self, input_data, source_lang: str, target_lang: str, service_id: str):
+        return {
+            "pipelineTasks": [
+                {
+                    "taskType": "translation",
+                    "config": {
+                        "language": {
+                            "sourceLanguage": source_lang,
+                            "targetLanguage": target_lang,
+                        },
+                        "serviceId": service_id,
+                    },
+                }
+            ],
+            "inputData": {"input": [{"source": input_data}]},
+        }
+
+    def _get_primary_service_id(self, source_lang: str, target_lang: str):
+        normalized_source = source_lang.strip().lower()
+        normalized_target = target_lang.strip().lower()
+        if {normalized_source, normalized_target}.issubset({"hi", "en"}):
+            return "bhashini/iiith/nmt-all"
+        return "bhashini/ai4bharat/indictrans-v3"
+
+    def _get_fallback_service_id(self, source_lang: str, target_lang: str):
+        normalized_source = source_lang.strip().lower()
+        normalized_target = target_lang.strip().lower()
+        if {normalized_source, normalized_target}.issubset({"hi", "en"}):
+            return "Bhashini/IIITH/Trans/V1"
+        return "ai4bharat/indictrans-v2-all-gpu--t4"
+
+    def postprocess(self, response):
+        try:
+            return (
+                response.get("pipelineResponse", [{}])[0]
+                .get("output", [{}])[0]
+                .get("target", "API Error")
+            ) or "API Error"
+        except Exception:
+            return "API Error"

bhashini_client_sdk-0.1.3/bhashini_client/services/transliteration_service.py

@@ -0,0 +1,49 @@
+class TransliterationService:
+    def __init__(self, handler):
+        self.handler = handler
+
+    def preprocess(self, input_data):
+        if input_data is None or not isinstance(input_data, str):
+            return "Invalid input"
+        cleaned_input = input_data.strip()
+        if not cleaned_input:
+            return "Invalid input"
+        return cleaned_input
+
+    def transliterate(self, input_data, source_lang: str, target_lang: str):
+        processed_input = self.preprocess(input_data)
+        if processed_input == "Invalid input":
+            return processed_input
+        payload = {
+            "pipelineTasks": [
+                {
+                    "taskType": "transliteration",
+                    "config": {
+                        "language": {
+                            "sourceLanguage": source_lang,
+                            "targetLanguage": target_lang,
+                        },
+                        "serviceId": "ai4bharat/indicxlit--cpu-fsv2",
+                        "isSentence": True,
+                        "numSuggestions": 1,
+                    },
+                }
+            ],
+            "inputData": {"input": [{"source": processed_input}]},
+        }
+        response = self.handler.post(payload)
+        if not response:
+            return "API Error"
+        return self.postprocess(response)
+
+    def postprocess(self, response):
+        try:
+            output = response.get("pipelineResponse", [{}])[0].get("output", [{}])[0]
+            if output.get("target"):
+                return output["target"]
+            suggestions = output.get("targetOptions", [])
+            if suggestions:
+                return suggestions[0]
+            return "API Error"
+        except Exception:
+            return "API Error"

bhashini_client_sdk-0.1.3/bhashini_client/services/tts_service.py

@@ -0,0 +1,52 @@
+import base64
+
+
+class TTSService:
+    def __init__(self, handler):
+        self.handler = handler
+
+    def preprocess(self, input_data):
+        if input_data is None or not isinstance(input_data, str):
+            return "Invalid input"
+        cleaned_input = input_data.strip()
+        if not cleaned_input:
+            return "Invalid input"
+        return cleaned_input
+
+    def synthesize(self, input_data, source_lang: str, gender: str = "female", output_file: str = "output.wav"):
+        processed_input = self.preprocess(input_data)
+        if processed_input == "Invalid input":
+            return processed_input
+        payload = {
+            "pipelineTasks": [
+                {
+                    "taskType": "tts",
+                    "config": {
+                        "language": {"sourceLanguage": source_lang},
+                        "gender": gender,
+                        "serviceId": "Bhashini/IITM/TTS",
+                    },
+                }
+            ],
+            "inputData": {"input": [{"source": processed_input}]},
+        }
+        response = self.handler.post(payload)
+        if not response:
+            return "API Error"
+        return self.postprocess(response, output_file)
+
+    def postprocess(self, response, output_file: str = "output.wav"):
+        try:
+            pipeline_response = response.get("pipelineResponse", [{}])[0]
+            audio_content = None
+            if pipeline_response.get("audio"):
+                audio_content = pipeline_response["audio"][0].get("audioContent")
+            if not audio_content and pipeline_response.get("output"):
+                audio_content = pipeline_response["output"][0].get("audio", {}).get("audioContent")
+            if not audio_content:
+                return "API Error"
+            with open(output_file, "wb") as audio_file:
+                audio_file.write(base64.b64decode(audio_content))
+            return output_file
+        except Exception:
+            return "API Error"

bhashini_client_sdk-0.1.3/bhashini_client/utils/request_handler.py

@@ -0,0 +1,25 @@
+import json
+from typing import Optional
+
+import requests
+
+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.headers = {**DEFAULT_HEADERS, "Authorization": auth_token}
+
+    def post(self, payload: dict):
+        try:
+            response = requests.post(
+                BASE_URL,
+                headers=self.headers,
+                data=json.dumps(payload),
+                timeout=DEFAULT_TIMEOUT,
+            )
+            response.raise_for_status()
+            return response.json()
+        except Exception:
+            return None

bhashini_client_sdk-0.1.3/bhashini_client_sdk.egg-info/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: bhashini-client-sdk
+Version: 0.1.3
+Summary: Python SDK for Bhashini APIs (ASR, NMT, TTS, Transliteration, Language Detection)
+Home-page: https://github.com/Nidhi18-git/bhashini-client.git
+Author: Nidhi Jha
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: openpyxl
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# bhashini-client-sdk
+
+A simple Python SDK for interacting with [Bhashini](https://bhashini.gov.in/) APIs.
+
+---
+
+## 🚀 Features
+
+* ASR (Automatic Speech Recognition)
+* NMT (Machine Translation)
+* TTS (Text-to-Speech)
+* Language Detection
+* Transliteration
+* ASR + NMT pipeline (Speech → Translation)
+
+---
+
+## 📦 Installation
+
+```bash
+pip install bhashini-client-sdk
+```
+
+---
+
+## 🔑 Setup
+
+Set your Bhashini API key:
+
+```bash
+# Windows PowerShell
+$env:BHASHINI_API_KEY="your_api_key"
+```
+
+---
+
+## 🧪 Example Usage
+
+```python
+from bhashini_client.core import BhashiniClient
+
+client = BhashiniClient()
+
+# Language Detection
+print(client.detect_language("Hello"))
+
+# Translation
+print(client.nmt("Hello", "en", "hi"))
+
+# Transliteration
+print(client.transliterate("namaste", "en", "hi"))
+
+# Text-to-Speech
+client.tts("Hello", "en")
+
+# ASR (Speech to Text)
+print(client.asr("sample.wav", "hi"))
+
+# ASR + NMT
+print(client.asr_nmt("sample.wav", "hi", "en"))
+```
+
+---
+
+## 🔊 TTS Output
+
+TTS generates an audio file:
+
+```
+output.wav
+```
+
+You can play it locally after generation.
+
+---
+
+## 📊 Testing
+
+* Includes edge case testing
+* Excel file (`test_results.xlsx`) generated for tracking results
+
+---
+
+## ⚙️ Requirements
+
+* Python 3.7+
+* requests
+* openpyxl
+
+---
+
+## 📌 Notes
+
+* API key is required for all services
+* Do NOT hardcode API key in code
+* Uses direct `serviceId` (no dynamic mapping)
+
+---
+
+## 👩‍💻 Author
+
+Nidhi Jha
+

bhashini_client_sdk-0.1.3/bhashini_client_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,28 @@
+LICENSE
+README.md
+setup.py
+bhashini_client/__init__.py
+bhashini_client/config.py
+bhashini_client/core.py
+bhashini_client/services/__init__.py
+bhashini_client/services/asr_service.py
+bhashini_client/services/language_detection_service.py
+bhashini_client/services/nmt_service.py
+bhashini_client/services/transliteration_service.py
+bhashini_client/services/tts_service.py
+bhashini_client/utils/__init__.py
+bhashini_client/utils/request_handler.py
+bhashini_client_sdk.egg-info/PKG-INFO
+bhashini_client_sdk.egg-info/SOURCES.txt
+bhashini_client_sdk.egg-info/dependency_links.txt
+bhashini_client_sdk.egg-info/requires.txt
+bhashini_client_sdk.egg-info/top_level.txt
+tests/__init__.py
+tests/conftest.py
+tests/result_logger.py
+tests/test_asr.py
+tests/test_asr_nmt.py
+tests/test_language_detection.py
+tests/test_nmt.py
+tests/test_transliteration.py
+tests/test_tts.py

bhashini_client_sdk-0.1.3/bhashini_client_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

bhashini_client_sdk-0.1.3/bhashini_client_sdk.egg-info/requires.txt

@@ -0,0 +1,2 @@
+requests
+openpyxl

bhashini_client_sdk-0.1.3/bhashini_client_sdk.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+bhashini_client
+tests

bhashini_client_sdk-0.1.3/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

bhashini_client_sdk-0.1.3/setup.py

@@ -0,0 +1,22 @@
+from setuptools import setup, find_packages
+from pathlib import Path
+
+setup(
+    name="bhashini-client-sdk",
+    version="0.1.3",
+    packages=find_packages(),
+    install_requires=[
+        "requests",
+        "openpyxl",
+    ],
+    author="Nidhi Jha",
+    description="Python SDK for Bhashini APIs (ASR, NMT, TTS, Transliteration, Language Detection)",
+    long_description=Path("README.md").read_text(encoding="utf-8"),
+    long_description_content_type="text/markdown",
+    url="https://github.com/Nidhi18-git/bhashini-client.git",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+    ],
+    python_requires=">=3.7",
+)

bhashini_client_sdk-0.1.3/tests/__init__.py

@@ -0,0 +1 @@
+

bhashini_client_sdk-0.1.3/tests/conftest.py

@@ -0,0 +1,27 @@
+from pathlib import Path
+
+from openpyxl import Workbook
+import pytest
+
+
+RESULT_FILE = Path(__file__).resolve().parents[1] / "test_results.xlsx"
+
+
+@pytest.fixture(scope="session", autouse=True)
+def initialize_result_file():
+    workbook = Workbook()
+    sheet = workbook.active
+    sheet.title = "Results"
+    sheet.append(
+        [
+            "Test ID",
+            "Service Name",
+            "Input",
+            "Expected Output",
+            "Actual Output",
+            "Status (Pass/Fail)",
+            "Remarks",
+        ]
+    )
+    workbook.save(RESULT_FILE)
+    yield

bhashini_client_sdk-0.1.3/tests/result_logger.py

@@ -0,0 +1,26 @@
+from pathlib import Path
+
+from openpyxl import load_workbook
+
+
+RESULT_FILE = Path(__file__).resolve().parents[1] / "test_results.xlsx"
+
+
+def log_test_result(test_id, service_name, input_value, expected_output, actual_output):
+    status = "Pass" if expected_output == actual_output else "Fail"
+    remarks = "" if status == "Pass" else "Mismatch"
+    workbook = load_workbook(RESULT_FILE)
+    sheet = workbook.active
+    sheet.append(
+        [
+            test_id,
+            service_name,
+            str(input_value),
+            expected_output,
+            actual_output,
+            status,
+            remarks,
+        ]
+    )
+    workbook.save(RESULT_FILE)
+    print(f'{test_id} | {service_name} | "{input_value}" | "{actual_output}"')

bhashini_client_sdk-0.1.3/tests/test_asr.py

@@ -0,0 +1,48 @@
+import base64
+
+from bhashini_client.services.asr_service import ASRService
+
+from tests.result_logger import log_test_result
+
+
+def test_asr_service_cases(tmp_path):
+    audio_file = tmp_path / "sample.wav"
+    audio_file.write_bytes(b"demo-audio")
+    audio_base64 = base64.b64encode(b"demo-audio").decode("utf-8")
+
+    cases = [
+        ("T001", str(audio_file), "demo transcription"),
+        ("T002", "", "Invalid input"),
+        ("T003", "   ", "Invalid input"),
+        ("T004", 123, "Invalid input"),
+        ("T005", audio_base64, "demo transcription"),
+        ("T006", ["audio"], "Invalid input"),
+    ]
+
+    for test_id, input_value, expected_output in cases:
+        service = ASRService(handler=None)
+        if expected_output != "Invalid input":
+            service.handler = type(
+                "Handler",
+                (),
+                {"post": lambda self, payload: {"pipelineResponse": [{"output": [{"source": "demo transcription"}]}]}},
+            )()
+        actual_output = service.transcribe(input_value, "en")
+        log_test_result(test_id, "ASR", input_value, expected_output, actual_output)
+        assert actual_output == expected_output
+
+
+def test_asr_uses_hindi_service_id():
+    captured = {}
+
+    class Handler:
+        def post(self, payload):
+            captured["serviceId"] = payload["pipelineTasks"][0]["config"]["serviceId"]
+            return {"pipelineResponse": [{"output": [{"source": "demo transcription"}]}]}
+
+    service = ASRService(Handler())
+    audio_base64 = base64.b64encode(b"demo-audio").decode("utf-8")
+    actual_output = service.transcribe(audio_base64, "hi")
+    log_test_result("T032", "ASR", "hi service id", "demo transcription", actual_output)
+    assert actual_output == "demo transcription"
+    assert captured["serviceId"] == "ai4bharat/conformer-hi-gpu--t4"

bhashini_client_sdk-0.1.3/tests/test_asr_nmt.py

@@ -0,0 +1,24 @@
+import base64
+
+from bhashini_client import BhashiniClient
+
+from tests.result_logger import log_test_result
+
+
+def test_asr_nmt_pipeline_case():
+    audio_base64 = base64.b64encode(b"demo-audio").decode("utf-8")
+    client = BhashiniClient(api_key="test-key")
+
+    responses = iter(
+        [
+            {"pipelineResponse": [{"output": [{"source": "Hello"}]}]},
+            {"pipelineResponse": [{"output": [{"target": "नमस्ते"}]}]},
+        ]
+    )
+
+    client.handler.post = lambda payload: next(responses)
+
+    actual_output = client.speech_translate(audio_base64, "en", "hi")
+    expected_output = "नमस्ते"
+    log_test_result("T031", "ASR + NMT", audio_base64, expected_output, actual_output)
+    assert actual_output == expected_output

bhashini_client_sdk-0.1.3/tests/test_language_detection.py

@@ -0,0 +1,30 @@
+from bhashini_client.services.language_detection_service import LanguageDetectionService
+
+from tests.result_logger import log_test_result
+
+
+def test_language_detection_service_cases():
+    cases = [
+        ("T025", "Hello", "en"),
+        ("T026", "", "Invalid input"),
+        ("T027", "   ", "Invalid input"),
+        ("T028", 123, "Invalid input"),
+        ("T029", "Hello नमस्ते 123", "en"),
+        ("T030", None, "Invalid input"),
+    ]
+
+    for test_id, input_value, expected_output in cases:
+        service = LanguageDetectionService(handler=None)
+        if expected_output != "Invalid input":
+            service.handler = type(
+                "Handler",
+                (),
+                {
+                    "post": lambda self, payload: {
+                        "pipelineResponse": [{"output": [{"langPrediction": [{"langCode": "en"}]}]}]
+                    }
+                },
+            )()
+        actual_output = service.detect(input_value)
+        log_test_result(test_id, "Language Detection", input_value, expected_output, actual_output)
+        assert actual_output == expected_output

bhashini_client_sdk-0.1.3/tests/test_nmt.py

@@ -0,0 +1,41 @@
+from bhashini_client.services.nmt_service import NMTService
+
+from tests.result_logger import log_test_result
+
+
+def test_nmt_service_cases():
+    cases = [
+        ("T007", "Hello", "नमस्ते"),
+        ("T008", "", "Invalid input"),
+        ("T009", "   ", "Invalid input"),
+        ("T010", 123, "Invalid input"),
+        ("T011", "Hello नमस्ते 123", "नमस्ते"),
+        ("T012", {"text": "Hello"}, "Invalid input"),
+    ]
+
+    for test_id, input_value, expected_output in cases:
+        service = NMTService(handler=None)
+        if expected_output != "Invalid input":
+            service.handler = type(
+                "Handler",
+                (),
+                {"post": lambda self, payload: {"pipelineResponse": [{"output": [{"target": "नमस्ते"}]}]}},
+            )()
+        actual_output = service.translate(input_value, "en", "hi")
+        log_test_result(test_id, "NMT", input_value, expected_output, actual_output)
+        assert actual_output == expected_output
+
+
+def test_nmt_uses_hindi_english_service_id():
+    captured = {}
+
+    class Handler:
+        def post(self, payload):
+            captured["serviceId"] = payload["pipelineTasks"][0]["config"]["serviceId"]
+            return {"pipelineResponse": [{"output": [{"target": "Hello"}]}]}
+
+    service = NMTService(Handler())
+    actual_output = service.translate("नमस्ते", "hi", "en")
+    log_test_result("T033", "NMT", "hi-en service id", "Hello", actual_output)
+    assert actual_output == "Hello"
+    assert captured["serviceId"] == "bhashini/iiith/nmt-all"

bhashini_client_sdk-0.1.3/tests/test_transliteration.py

@@ -0,0 +1,26 @@
+from bhashini_client.services.transliteration_service import TransliterationService
+
+from tests.result_logger import log_test_result
+
+
+def test_transliteration_service_cases():
+    cases = [
+        ("T019", "namaste", "नमस्ते"),
+        ("T020", "", "Invalid input"),
+        ("T021", "   ", "Invalid input"),
+        ("T022", 123, "Invalid input"),
+        ("T023", "naमaste123", "नमस्ते"),
+        ("T024", ("namaste",), "Invalid input"),
+    ]
+
+    for test_id, input_value, expected_output in cases:
+        service = TransliterationService(handler=None)
+        if expected_output != "Invalid input":
+            service.handler = type(
+                "Handler",
+                (),
+                {"post": lambda self, payload: {"pipelineResponse": [{"output": [{"target": "नमस्ते"}]}]}},
+            )()
+        actual_output = service.transliterate(input_value, "en", "hi")
+        log_test_result(test_id, "Transliteration", input_value, expected_output, actual_output)
+        assert actual_output == expected_output

bhashini_client_sdk-0.1.3/tests/test_tts.py

@@ -0,0 +1,40 @@
+import base64
+from pathlib import Path
+
+from bhashini_client.services.tts_service import TTSService
+
+from tests.result_logger import log_test_result
+
+
+def test_tts_service_cases(tmp_path):
+    output_file = tmp_path / "output.wav"
+    audio_base64 = base64.b64encode(b"wave-bytes").decode("utf-8")
+    cases = [
+        ("T013", "Hello", str(output_file)),
+        ("T014", "", "Invalid input"),
+        ("T015", "   ", "Invalid input"),
+        ("T016", 123, "Invalid input"),
+        ("T017", "Hello नमस्ते 123", str(output_file)),
+        ("T018", ["Hello"], "Invalid input"),
+    ]
+
+    for test_id, input_value, expected_output in cases:
+        service = TTSService(handler=None)
+        current_output = expected_output if expected_output.endswith(".wav") else str(output_file)
+        if Path(current_output).exists():
+            Path(current_output).unlink()
+        if expected_output != "Invalid input":
+            service.handler = type(
+                "Handler",
+                (),
+                {
+                    "post": lambda self, payload: {
+                        "pipelineResponse": [{"audio": [{"audioContent": audio_base64}]}]
+                    }
+                },
+            )()
+        actual_output = service.synthesize(input_value, "en", output_file=current_output)
+        log_test_result(test_id, "TTS", input_value, expected_output, actual_output)
+        assert actual_output == expected_output
+        if actual_output.endswith(".wav"):
+            assert Path(actual_output).exists()