dwani 0.1.2__tar.gz → 0.1.4__tar.gz

dwani-0.1.4/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: dwani
+Version: 0.1.4
+Summary: Multimodal API for Indian languages (speech, vision, LLMs, TTS, ASR, etc.)
+Author-email: sachin <python@dwani.ai>
+License: MIT License
+        
+        Copyright (c) 2025 Sachin Shetty
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/dwani-ai/dwani-python
+Project-URL: Source, https://github.com/dwani-ai/dwani-python
+Project-URL: Issues, https://github.com/dwani-ai/dwani-python/issues
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25.0
+Dynamic: license-file
+
+# dwani.ai - python library
+
+
+```bash
+pip install dwani
+```
+
+
+
+```python
+import dwani
+import os
+
+dwani.api_key = os.getenv("DWANI_API_KEY")
+
+dwani.api_base = os.getenv("DWANI_API_BASE_URL")
+
+resp = dwani.Chat.create("Hello!", "eng_Latn", "kan_Knda")
+print(resp)
+```
+
+
+<!-- 
+## local development
+pip install -e .
+
+
+pip install twine build
+rm -rf dist/
+python -m build
+
+python -m twine upload dist/*
+
+-->

dwani-0.1.4/README.md

@@ -0,0 +1,34 @@
+# dwani.ai - python library
+
+
+```bash
+pip install dwani
+```
+
+
+
+```python
+import dwani
+import os
+
+dwani.api_key = os.getenv("DWANI_API_KEY")
+
+dwani.api_base = os.getenv("DWANI_API_BASE_URL")
+
+resp = dwani.Chat.create("Hello!", "eng_Latn", "kan_Knda")
+print(resp)
+```
+
+
+<!-- 
+## local development
+pip install -e .
+
+
+pip install twine build
+rm -rf dist/
+python -m build
+
+python -m twine upload dist/*
+
+-->

dwani-0.1.2/dwani/vision.py → dwani-0.1.4/dwani/asr.py

@@ -1,21 +1,20 @@
 from .exceptions import DhwaniAPIError
 import requests
-def vision_caption(client, file_path, length="short"):
+def asr_transcribe(client, file_path, language):
     with open(file_path, "rb") as f:
         files = {"file": f}
-        data = {"length": length}
         resp = requests.post(
-            f"{client.api_base}/caption/",
+            f"{client.api_base}/v1/transcribe/?language={language}",
             headers=client._headers(),
-            files=files,
-            data=data
+            files=files
         )
     if resp.status_code != 200:
         raise DhwaniAPIError(resp)
     return resp.json()
 
-class Vision:
+class ASR:
     @staticmethod
-    def caption(*args, **kwargs):
+    def transcribe(*args, **kwargs):
         from . import _get_client
-        return _get_client().caption(*args, **kwargs)
+        return _get_client().transcribe(*args, **kwargs)
+

{dwani-0.1.2 → dwani-0.1.4}/dwani/audio.py

@@ -1,16 +1,16 @@
 from .exceptions import DhwaniAPIError
 import requests
-def audio_speech(client, input, voice, model, response_format="mp3", output_file=None):
-    data = {
+
+def audio_speech(client, input, response_format="mp3", output_file=None):
+    params = {
         "input": input,
-        "voice": voice,
-        "model": model,
         "response_format": response_format
     }
     resp = requests.post(
         f"{client.api_base}/v1/audio/speech",
-        headers={**client._headers(), "Content-Type": "application/json"},
-        json=data,
+        headers={**client._headers(), "accept": "application/json"},
+        params=params,
+        data='',  # Empty body, as in the curl example
         stream=True
     )
     if resp.status_code != 200:

dwani-0.1.4/dwani/chat.py

@@ -0,0 +1,25 @@
+from .exceptions import DhwaniAPIError
+import requests
+
+def chat_create(client, prompt, src_lang, tgt_lang, **kwargs):
+    url = f"{client.api_base}/v1/indic_chat"
+    payload = {
+        "prompt": prompt,
+        "src_lang": src_lang,
+        "tgt_lang": tgt_lang
+    }
+    payload.update(kwargs)
+    resp = requests.post(
+        url,
+        headers={**client._headers(), "Content-Type": "application/json"},
+        json=payload
+    )
+    if resp.status_code != 200:
+        raise DhwaniAPIError(resp)
+    return resp.json()
+
+class Chat:
+    @staticmethod
+    def create(prompt, src_lang, tgt_lang, **kwargs):
+        from . import _get_client
+        return _get_client().chat(prompt, src_lang, tgt_lang, **kwargs)

{dwani-0.1.2 → dwani-0.1.4}/dwani/client.py

@@ -4,26 +4,25 @@ from .exceptions import DhwaniAPIError
 
 class DhwaniClient:
     def __init__(self, api_key=None, api_base=None):
-        self.api_key = api_key or os.getenv("DHWANI_API_KEY")
-        self.api_base = "https://dwani-dwani-server-workshop.hf.space"
-        #self.api_base = api_base or os.getenv("DHWANI_API_BASE", "http://localhost:7860")
+        self.api_key = api_key or os.getenv("DWANI_API_KEY")
+        self.api_base = api_base or os.getenv("DWANI_API_BASE_URL", "http://localhost:7860")
         if not self.api_key:
             raise ValueError("DHWANI_API_KEY not set")
 
     def _headers(self):
         return {"X-API-Key": self.api_key}
 
-    def chat(self, prompt, **kwargs):
+    def chat(self, prompt, src_lang, tgt_lang, **kwargs):
         from .chat import chat_create
-        return chat_create(self, prompt, **kwargs)
+        return chat_create(self, prompt, src_lang, tgt_lang, **kwargs)
 
     def speech(self, *args, **kwargs):
         from .audio import audio_speech
         return audio_speech(self, *args, **kwargs)
 
-    def caption(self, *args, **kwargs):
+    def caption(self, file_path, query="describe the image", src_lang="eng_Latn", tgt_lang="kan_Knda"):
         from .vision import vision_caption
-        return vision_caption(self, *args, **kwargs)
+        return vision_caption(self, file_path, query, src_lang, tgt_lang)
 
     def transcribe(self, *args, **kwargs):
         from .asr import asr_transcribe

dwani-0.1.4/dwani/vision.py

@@ -0,0 +1,31 @@
+from .exceptions import DhwaniAPIError
+import requests
+def vision_caption(client, file_path, query="describe the image", src_lang="eng_Latn", tgt_lang="kan_Knda"):
+    # Build the endpoint using the client's api_base
+    url = (
+        f"{client.api_base}/v1/indic_visual_query"
+        f"?src_lang={src_lang}&tgt_lang={tgt_lang}"
+    )
+    headers = {
+        **client._headers(),
+        "accept": "application/json"
+        # Note: 'Content-Type' will be set automatically by requests when using 'files'
+    }
+    with open(file_path, "rb") as f:
+        files = {"file": (file_path, f, "image/png")}
+        data = {"query": query}
+        resp = requests.post(
+            url,
+            headers=headers,
+            files=files,
+            data=data
+        )
+    if resp.status_code != 200:
+        raise DhwaniAPIError(resp)
+    return resp.json()
+
+class Vision:
+    @staticmethod
+    def caption(*args, **kwargs):
+        from . import _get_client
+        return _get_client().caption(*args, **kwargs)

dwani-0.1.4/dwani.egg-info/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: dwani
+Version: 0.1.4
+Summary: Multimodal API for Indian languages (speech, vision, LLMs, TTS, ASR, etc.)
+Author-email: sachin <python@dwani.ai>
+License: MIT License
+        
+        Copyright (c) 2025 Sachin Shetty
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/dwani-ai/dwani-python
+Project-URL: Source, https://github.com/dwani-ai/dwani-python
+Project-URL: Issues, https://github.com/dwani-ai/dwani-python/issues
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25.0
+Dynamic: license-file
+
+# dwani.ai - python library
+
+
+```bash
+pip install dwani
+```
+
+
+
+```python
+import dwani
+import os
+
+dwani.api_key = os.getenv("DWANI_API_KEY")
+
+dwani.api_base = os.getenv("DWANI_API_BASE_URL")
+
+resp = dwani.Chat.create("Hello!", "eng_Latn", "kan_Knda")
+print(resp)
+```
+
+
+<!-- 
+## local development
+pip install -e .
+
+
+pip install twine build
+rm -rf dist/
+python -m build
+
+python -m twine upload dist/*
+
+-->

dwani-0.1.4/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "dwani"
+version = "0.1.4"
+description = "Multimodal API for Indian languages (speech, vision, LLMs, TTS, ASR, etc.)"
+authors = [
+    { name="sachin", email="python@dwani.ai" }
+]
+readme = "README.md"
+license = { file = "LICENSE" }
+requires-python = ">=3.8"
+
+dependencies = [
+    "requests>=2.25.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/dwani-ai/dwani-python"
+Source = "https://github.com/dwani-ai/dwani-python"
+Issues = "https://github.com/dwani-ai/dwani-python/issues"

dwani-0.1.2/PKG-INFO

@@ -1,188 +0,0 @@
-Metadata-Version: 2.4
-Name: dwani
-Version: 0.1.2
-Summary: Multimodal AI server for Indian languages (speech, vision, LLMs, TTS, ASR, etc.)
-Author-email: sachin <python@dwani.ai>
-License: MIT License
-        
-        Copyright (c) 2025 Sachin Shetty
-        
-        Permission is hereby granted, free of charge, to any person obtaining a copy
-        of this software and associated documentation files (the "Software"), to deal
-        in the Software without restriction, including without limitation the rights
-        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-        copies of the Software, and to permit persons to whom the Software is
-        furnished to do so, subject to the following conditions:
-        
-        The above copyright notice and this permission notice shall be included in all
-        copies or substantial portions of the Software.
-        
-        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-        SOFTWARE.
-        
-Project-URL: Homepage, https://github.com/dwani-ai/dwani-server
-Project-URL: Source, https://github.com/dwani-ai/dwani-server
-Project-URL: Issues, https://github.com/dwani-ai/dwani-server/issues
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: requests>=2.25.0
-Dynamic: license-file
-
-# Dhwani Server
-
-Dhwani API is a FastAPI-based application providing AI-powered services for Indian languages, including text-to-speech (TTS), language model (LLM) chat, vision-language model (VLM) capabilities, and automatic speech recognition (ASR). It supports lazy loading of models for fast startup and includes endpoints for various tasks.
-
-## Features
-- **Text-to-Speech (TTS)**: Generate audio from text in Indian languages using Parler TTS.
-- **Chat**: Process Kannada prompts and respond in Kannada via translation and LLM.
-- **Vision-Language Model (VLM)**: Caption images, answer visual queries, detect, and point objects.
-- **Automatic Speech Recognition (ASR)**: Transcribe audio files in multiple Indian languages.
-- **Lazy Loading**: Models load on-demand or via an explicit endpoint for fast startup.
-
-## Prerequisites
-- **System Requirements - User **:
-    - **Python**: 3.10
-    - Ubuntu 22.04
-    - git 
-    - vscode
-- **System Requirements - Server **:
-  - Ubuntu with sufficient RAM (16GB+ recommended for models).
-  - Optional: NVIDIA GPU with CUDA support for faster inference.
-- **FFmpeg**: Required for audio processing (ASR).
-
-- Server Setup
-```bash
-export HF_HOME=/home/ubuntu/data-dhwani-models
-export HF_TOKEN='YOur-HF-token'
-python src/server/main.py --host 0.0.0.0 --port 7860 --config config_two
-```
-## Installation
-
-1. **Clone the Repository**:
-   ```bash
-   git clone https://github.com/slabstech/dhwani-server
-   cd dhwani-server
-   ```
-
-2. Install Libraries:
-    - On Ubuntu: ```sudo apt-get install ffmpeg build-essential```
-
-3. Set Up Virtual Environment:
-    ```bash
-    python -m venv venv
-    source venv/bin/activate 
-    ```
-4. Install Dependencies:
-    ```bash
-    sudo apt-get install -y ffmpeg build-essential
-    curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --no-modify-path --profile minimal
-    . "$HOME/.cargo/env"
-    export CC=/usr/bin/gcc
-    export ENV CXX=/usr/bin/g++
-    ```
-    ```bash
-    pip install --no-cache-dir --upgrade pip setuptools psutil setuptools-rust torch==2.6.0
-    pip install --no-cache-dir flash-attn --no-build-isolation
-    ```
-
-    ```bash
-    pip install -r requirements.txt
-    ```
-    
-4. Set Environment Variable:
-    Create a .env file in the root directory and add your API key:
-    plaintext
-    ```bash
-    API_KEY=your_secret_key
-    ```
-
-5. Running the Server
-    - Start the Server:
-    ```bash
-        python src/server/main.py --host 0.0.0.0 --port 7860 --config config_two
-    ```
-
-    - The server starts with models loaded on start
-    - Access the interactive API docs at http://localhost:7860/docs.
-    
-    - (Optional) Load All Models:
-    Preload all models (LLM, Translation, TTS, VLM, ASR) with:
-    - 
-    ```bash
-    curl -X POST "http://localhost:7860/load_all_models" -H "X-API-Key: your_secret_key"
-    ```
-
-- Usage
-    - Endpoints
-        - All endpoints require the X-API-Key header with the value from your .env file.
-
-    -    Health Check: GET /health
-    ```bash
-        curl "http://localhost:7860/health"
-    ```
-    - Response: 
-        ```bash 
-        {"status": "healthy", "model": "Qwen/Qwen2.5-3B-Instruct"}
-        ```
-    
-    - Text-to-Speech: POST /v1/audio/speech
-    ```  bash
-    curl -X POST "http://localhost:7860/v1/audio/speech" -H "X-API-Key: your_secret_key" -H "Content-Type: application/json" -d '{"input": "ನಮಸ್ಕಾರ", "voice": "Female voice", "model": "ai4bharat/indic-parler-tts", "response_format": "mp3"}' --output speech.mp3
-    ```
-    - Chat: POST /chat
-    ``` bash
-        curl -X POST "http://localhost:7860/chat" -H "X-API-Key: your_secret_key" -H "Content-Type: application/json" -d '{"prompt": "ನೀವು ಹೇಗಿದ್ದೀರಿ?"}'
-    ```
-
-    - Response: 
-            ```{"response": "<Kannada response>"}```
-    - Image Captioning: POST /caption/
-    ```bash
-        curl -X POST "http://localhost:7860/caption/" -H "X-API-Key: your_secret_key" -F "file=@image.jpg" -F "length=short"
-    ```
-    - Response:``` {"caption": "<short caption>"}```
-    - Visual Query: POST /visual_query/
-    ```bash
-        curl -X POST "http://localhost:7860/visual_query/" -H "X-API-Key: your_secret_key" -F "file=@image.jpg" -F "query=What is this?"
-    ```
-    - Response: ```{"answer": "<answer>"}```
-    - Object Detection: POST /detect/
-    ```bash
-        curl -X POST "http://localhost:7860/detect/" -H "X-API-Key: your_secret_key" -F "file=@image.jpg" -F "object_type=face"
-    ```
-    - Response: ```{"objects": [<list of detected objects>]}```
-    - Object Pointing: POST /point/
-    ```bash
-
-        curl -X POST "http://localhost:7860/point/" -H "X-API-Key: your_secret_key" -F "file=@image.jpg" -F "object_type=person"
-    ```
-    - Response: ```{"points": [<list of points>]}```
-    - Transcription: POST /transcribe/
-    ```bash
-    curl -X POST "http://localhost:7860/transcribe/?language=kannada" -H "X-API-Key: your_secret_key" -F "file=@audio.wav"
-    ```
-    - Response: ```{"text": "<transcribed text>"}```
-    - Batch Transcription: POST /transcribe_batch/
-    ```bash
-    curl -X POST "http://localhost:7860/transcribe_batch/?language=kannada" -H "X-API-Key: your_secret_key" -F "files=@audio1.wav" -F "files=@audio2.mp3"
-    ```
-    - Response: ```{"transcriptions": ["<text1>", "<text2>"]}```
-
-- Notes
-    - Lazy Loading: Models load on first use or via /load_all_models. Expect a delay on the first request for each model type.
-    Supported Languages: ASR supports multiple Indian languages (e.g., kannada, hindi, tamil); see models/asr.py for the full list.
-    Logs: Check dhwani_api.log for detailed logs (rotated at 10MB, 5 backups).
-    Performance: Use a GPU with flash-attn installed for faster TTS and ASR inference.
-
-- Troubleshooting
-
-    - Module Errors: Ensure all dependencies are installed. Re-run pip install if needed.
-    FFmpeg Not Found: Install FFmpeg and ensure it’s in your PATH.
-    Permission Denied: Run with sudo if accessing restricted ports (e.g., < 1024).
-

dwani-0.1.2/README.md

@@ -1,152 +0,0 @@
-# Dhwani Server
-
-Dhwani API is a FastAPI-based application providing AI-powered services for Indian languages, including text-to-speech (TTS), language model (LLM) chat, vision-language model (VLM) capabilities, and automatic speech recognition (ASR). It supports lazy loading of models for fast startup and includes endpoints for various tasks.
-
-## Features
-- **Text-to-Speech (TTS)**: Generate audio from text in Indian languages using Parler TTS.
-- **Chat**: Process Kannada prompts and respond in Kannada via translation and LLM.
-- **Vision-Language Model (VLM)**: Caption images, answer visual queries, detect, and point objects.
-- **Automatic Speech Recognition (ASR)**: Transcribe audio files in multiple Indian languages.
-- **Lazy Loading**: Models load on-demand or via an explicit endpoint for fast startup.
-
-## Prerequisites
-- **System Requirements - User **:
-    - **Python**: 3.10
-    - Ubuntu 22.04
-    - git 
-    - vscode
-- **System Requirements - Server **:
-  - Ubuntu with sufficient RAM (16GB+ recommended for models).
-  - Optional: NVIDIA GPU with CUDA support for faster inference.
-- **FFmpeg**: Required for audio processing (ASR).
-
-- Server Setup
-```bash
-export HF_HOME=/home/ubuntu/data-dhwani-models
-export HF_TOKEN='YOur-HF-token'
-python src/server/main.py --host 0.0.0.0 --port 7860 --config config_two
-```
-## Installation
-
-1. **Clone the Repository**:
-   ```bash
-   git clone https://github.com/slabstech/dhwani-server
-   cd dhwani-server
-   ```
-
-2. Install Libraries:
-    - On Ubuntu: ```sudo apt-get install ffmpeg build-essential```
-
-3. Set Up Virtual Environment:
-    ```bash
-    python -m venv venv
-    source venv/bin/activate 
-    ```
-4. Install Dependencies:
-    ```bash
-    sudo apt-get install -y ffmpeg build-essential
-    curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --no-modify-path --profile minimal
-    . "$HOME/.cargo/env"
-    export CC=/usr/bin/gcc
-    export ENV CXX=/usr/bin/g++
-    ```
-    ```bash
-    pip install --no-cache-dir --upgrade pip setuptools psutil setuptools-rust torch==2.6.0
-    pip install --no-cache-dir flash-attn --no-build-isolation
-    ```
-
-    ```bash
-    pip install -r requirements.txt
-    ```
-    
-4. Set Environment Variable:
-    Create a .env file in the root directory and add your API key:
-    plaintext
-    ```bash
-    API_KEY=your_secret_key
-    ```
-
-5. Running the Server
-    - Start the Server:
-    ```bash
-        python src/server/main.py --host 0.0.0.0 --port 7860 --config config_two
-    ```
-
-    - The server starts with models loaded on start
-    - Access the interactive API docs at http://localhost:7860/docs.
-    
-    - (Optional) Load All Models:
-    Preload all models (LLM, Translation, TTS, VLM, ASR) with:
-    - 
-    ```bash
-    curl -X POST "http://localhost:7860/load_all_models" -H "X-API-Key: your_secret_key"
-    ```
-
-- Usage
-    - Endpoints
-        - All endpoints require the X-API-Key header with the value from your .env file.
-
-    -    Health Check: GET /health
-    ```bash
-        curl "http://localhost:7860/health"
-    ```
-    - Response: 
-        ```bash 
-        {"status": "healthy", "model": "Qwen/Qwen2.5-3B-Instruct"}
-        ```
-    
-    - Text-to-Speech: POST /v1/audio/speech
-    ```  bash
-    curl -X POST "http://localhost:7860/v1/audio/speech" -H "X-API-Key: your_secret_key" -H "Content-Type: application/json" -d '{"input": "ನಮಸ್ಕಾರ", "voice": "Female voice", "model": "ai4bharat/indic-parler-tts", "response_format": "mp3"}' --output speech.mp3
-    ```
-    - Chat: POST /chat
-    ``` bash
-        curl -X POST "http://localhost:7860/chat" -H "X-API-Key: your_secret_key" -H "Content-Type: application/json" -d '{"prompt": "ನೀವು ಹೇಗಿದ್ದೀರಿ?"}'
-    ```
-
-    - Response: 
-            ```{"response": "<Kannada response>"}```
-    - Image Captioning: POST /caption/
-    ```bash
-        curl -X POST "http://localhost:7860/caption/" -H "X-API-Key: your_secret_key" -F "file=@image.jpg" -F "length=short"
-    ```
-    - Response:``` {"caption": "<short caption>"}```
-    - Visual Query: POST /visual_query/
-    ```bash
-        curl -X POST "http://localhost:7860/visual_query/" -H "X-API-Key: your_secret_key" -F "file=@image.jpg" -F "query=What is this?"
-    ```
-    - Response: ```{"answer": "<answer>"}```
-    - Object Detection: POST /detect/
-    ```bash
-        curl -X POST "http://localhost:7860/detect/" -H "X-API-Key: your_secret_key" -F "file=@image.jpg" -F "object_type=face"
-    ```
-    - Response: ```{"objects": [<list of detected objects>]}```
-    - Object Pointing: POST /point/
-    ```bash
-
-        curl -X POST "http://localhost:7860/point/" -H "X-API-Key: your_secret_key" -F "file=@image.jpg" -F "object_type=person"
-    ```
-    - Response: ```{"points": [<list of points>]}```
-    - Transcription: POST /transcribe/
-    ```bash
-    curl -X POST "http://localhost:7860/transcribe/?language=kannada" -H "X-API-Key: your_secret_key" -F "file=@audio.wav"
-    ```
-    - Response: ```{"text": "<transcribed text>"}```
-    - Batch Transcription: POST /transcribe_batch/
-    ```bash
-    curl -X POST "http://localhost:7860/transcribe_batch/?language=kannada" -H "X-API-Key: your_secret_key" -F "files=@audio1.wav" -F "files=@audio2.mp3"
-    ```
-    - Response: ```{"transcriptions": ["<text1>", "<text2>"]}```
-
-- Notes
-    - Lazy Loading: Models load on first use or via /load_all_models. Expect a delay on the first request for each model type.
-    Supported Languages: ASR supports multiple Indian languages (e.g., kannada, hindi, tamil); see models/asr.py for the full list.
-    Logs: Check dhwani_api.log for detailed logs (rotated at 10MB, 5 backups).
-    Performance: Use a GPU with flash-attn installed for faster TTS and ASR inference.
-
-- Troubleshooting
-
-    - Module Errors: Ensure all dependencies are installed. Re-run pip install if needed.
-    FFmpeg Not Found: Install FFmpeg and ensure it’s in your PATH.
-    Permission Denied: Run with sudo if accessing restricted ports (e.g., < 1024).
-

dwani-0.1.2/dwani/asr.py

@@ -1,37 +0,0 @@
-from .exceptions import DhwaniAPIError
-import requests
-def asr_transcribe(client, file_path, language):
-    with open(file_path, "rb") as f:
-        files = {"file": f}
-        resp = requests.post(
-            f"{client.api_base}/transcribe/?language={language}",
-            headers=client._headers(),
-            files=files
-        )
-    if resp.status_code != 200:
-        raise DhwaniAPIError(resp)
-    return resp.json()
-
-class ASR:
-    @staticmethod
-    def transcribe(*args, **kwargs):
-        from . import _get_client
-        return _get_client().transcribe(*args, **kwargs)
-
-
-'''
-from .docs import Documents
-
-class documents:
-    @staticmethod
-    def ocr(file_path, language=None):
-        return _get_client().document_ocr(file_path, language)
-
-    @staticmethod
-    def translate(file_path, src_lang, tgt_lang):
-        return _get_client().document_translate(file_path, src_lang, tgt_lang)
-
-    @staticmethod
-    def summarize(file_path, language=None):
-        return _get_client().document_summarize(file_path, language)
-'''

dwani-0.1.2/dwani/chat.py

@@ -1,17 +0,0 @@
-from .exceptions import DhwaniAPIError
-import requests
-def chat_create(client, prompt, **kwargs):
-    resp = requests.post(
-        f"{client.api_base}/chat",
-        headers={**client._headers(), "Content-Type": "application/json"},
-        json={"prompt": prompt, **kwargs}
-    )
-    if resp.status_code != 200:
-        raise DhwaniAPIError(resp)
-    return resp.json()
-
-class Chat:
-    @staticmethod
-    def create(prompt, **kwargs):
-        from . import _get_client
-        return _get_client().chat(prompt, **kwargs)

dwani-0.1.2/dwani.egg-info/PKG-INFO

@@ -1,188 +0,0 @@
-Metadata-Version: 2.4
-Name: dwani
-Version: 0.1.2
-Summary: Multimodal AI server for Indian languages (speech, vision, LLMs, TTS, ASR, etc.)
-Author-email: sachin <python@dwani.ai>
-License: MIT License
-        
-        Copyright (c) 2025 Sachin Shetty
-        
-        Permission is hereby granted, free of charge, to any person obtaining a copy
-        of this software and associated documentation files (the "Software"), to deal
-        in the Software without restriction, including without limitation the rights
-        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-        copies of the Software, and to permit persons to whom the Software is
-        furnished to do so, subject to the following conditions:
-        
-        The above copyright notice and this permission notice shall be included in all
-        copies or substantial portions of the Software.
-        
-        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-        SOFTWARE.
-        
-Project-URL: Homepage, https://github.com/dwani-ai/dwani-server
-Project-URL: Source, https://github.com/dwani-ai/dwani-server
-Project-URL: Issues, https://github.com/dwani-ai/dwani-server/issues
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: requests>=2.25.0
-Dynamic: license-file
-
-# Dhwani Server
-
-Dhwani API is a FastAPI-based application providing AI-powered services for Indian languages, including text-to-speech (TTS), language model (LLM) chat, vision-language model (VLM) capabilities, and automatic speech recognition (ASR). It supports lazy loading of models for fast startup and includes endpoints for various tasks.
-
-## Features
-- **Text-to-Speech (TTS)**: Generate audio from text in Indian languages using Parler TTS.
-- **Chat**: Process Kannada prompts and respond in Kannada via translation and LLM.
-- **Vision-Language Model (VLM)**: Caption images, answer visual queries, detect, and point objects.
-- **Automatic Speech Recognition (ASR)**: Transcribe audio files in multiple Indian languages.
-- **Lazy Loading**: Models load on-demand or via an explicit endpoint for fast startup.
-
-## Prerequisites
-- **System Requirements - User **:
-    - **Python**: 3.10
-    - Ubuntu 22.04
-    - git 
-    - vscode
-- **System Requirements - Server **:
-  - Ubuntu with sufficient RAM (16GB+ recommended for models).
-  - Optional: NVIDIA GPU with CUDA support for faster inference.
-- **FFmpeg**: Required for audio processing (ASR).
-
-- Server Setup
-```bash
-export HF_HOME=/home/ubuntu/data-dhwani-models
-export HF_TOKEN='YOur-HF-token'
-python src/server/main.py --host 0.0.0.0 --port 7860 --config config_two
-```
-## Installation
-
-1. **Clone the Repository**:
-   ```bash
-   git clone https://github.com/slabstech/dhwani-server
-   cd dhwani-server
-   ```
-
-2. Install Libraries:
-    - On Ubuntu: ```sudo apt-get install ffmpeg build-essential```
-
-3. Set Up Virtual Environment:
-    ```bash
-    python -m venv venv
-    source venv/bin/activate 
-    ```
-4. Install Dependencies:
-    ```bash
-    sudo apt-get install -y ffmpeg build-essential
-    curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --no-modify-path --profile minimal
-    . "$HOME/.cargo/env"
-    export CC=/usr/bin/gcc
-    export ENV CXX=/usr/bin/g++
-    ```
-    ```bash
-    pip install --no-cache-dir --upgrade pip setuptools psutil setuptools-rust torch==2.6.0
-    pip install --no-cache-dir flash-attn --no-build-isolation
-    ```
-
-    ```bash
-    pip install -r requirements.txt
-    ```
-    
-4. Set Environment Variable:
-    Create a .env file in the root directory and add your API key:
-    plaintext
-    ```bash
-    API_KEY=your_secret_key
-    ```
-
-5. Running the Server
-    - Start the Server:
-    ```bash
-        python src/server/main.py --host 0.0.0.0 --port 7860 --config config_two
-    ```
-
-    - The server starts with models loaded on start
-    - Access the interactive API docs at http://localhost:7860/docs.
-    
-    - (Optional) Load All Models:
-    Preload all models (LLM, Translation, TTS, VLM, ASR) with:
-    - 
-    ```bash
-    curl -X POST "http://localhost:7860/load_all_models" -H "X-API-Key: your_secret_key"
-    ```
-
-- Usage
-    - Endpoints
-        - All endpoints require the X-API-Key header with the value from your .env file.
-
-    -    Health Check: GET /health
-    ```bash
-        curl "http://localhost:7860/health"
-    ```
-    - Response: 
-        ```bash 
-        {"status": "healthy", "model": "Qwen/Qwen2.5-3B-Instruct"}
-        ```
-    
-    - Text-to-Speech: POST /v1/audio/speech
-    ```  bash
-    curl -X POST "http://localhost:7860/v1/audio/speech" -H "X-API-Key: your_secret_key" -H "Content-Type: application/json" -d '{"input": "ನಮಸ್ಕಾರ", "voice": "Female voice", "model": "ai4bharat/indic-parler-tts", "response_format": "mp3"}' --output speech.mp3
-    ```
-    - Chat: POST /chat
-    ``` bash
-        curl -X POST "http://localhost:7860/chat" -H "X-API-Key: your_secret_key" -H "Content-Type: application/json" -d '{"prompt": "ನೀವು ಹೇಗಿದ್ದೀರಿ?"}'
-    ```
-
-    - Response: 
-            ```{"response": "<Kannada response>"}```
-    - Image Captioning: POST /caption/
-    ```bash
-        curl -X POST "http://localhost:7860/caption/" -H "X-API-Key: your_secret_key" -F "file=@image.jpg" -F "length=short"
-    ```
-    - Response:``` {"caption": "<short caption>"}```
-    - Visual Query: POST /visual_query/
-    ```bash
-        curl -X POST "http://localhost:7860/visual_query/" -H "X-API-Key: your_secret_key" -F "file=@image.jpg" -F "query=What is this?"
-    ```
-    - Response: ```{"answer": "<answer>"}```
-    - Object Detection: POST /detect/
-    ```bash
-        curl -X POST "http://localhost:7860/detect/" -H "X-API-Key: your_secret_key" -F "file=@image.jpg" -F "object_type=face"
-    ```
-    - Response: ```{"objects": [<list of detected objects>]}```
-    - Object Pointing: POST /point/
-    ```bash
-
-        curl -X POST "http://localhost:7860/point/" -H "X-API-Key: your_secret_key" -F "file=@image.jpg" -F "object_type=person"
-    ```
-    - Response: ```{"points": [<list of points>]}```
-    - Transcription: POST /transcribe/
-    ```bash
-    curl -X POST "http://localhost:7860/transcribe/?language=kannada" -H "X-API-Key: your_secret_key" -F "file=@audio.wav"
-    ```
-    - Response: ```{"text": "<transcribed text>"}```
-    - Batch Transcription: POST /transcribe_batch/
-    ```bash
-    curl -X POST "http://localhost:7860/transcribe_batch/?language=kannada" -H "X-API-Key: your_secret_key" -F "files=@audio1.wav" -F "files=@audio2.mp3"
-    ```
-    - Response: ```{"transcriptions": ["<text1>", "<text2>"]}```
-
-- Notes
-    - Lazy Loading: Models load on first use or via /load_all_models. Expect a delay on the first request for each model type.
-    Supported Languages: ASR supports multiple Indian languages (e.g., kannada, hindi, tamil); see models/asr.py for the full list.
-    Logs: Check dhwani_api.log for detailed logs (rotated at 10MB, 5 backups).
-    Performance: Use a GPU with flash-attn installed for faster TTS and ASR inference.
-
-- Troubleshooting
-
-    - Module Errors: Ensure all dependencies are installed. Re-run pip install if needed.
-    FFmpeg Not Found: Install FFmpeg and ensure it’s in your PATH.
-    Permission Denied: Run with sudo if accessing restricted ports (e.g., < 1024).
-

dwani-0.1.2/pyproject.toml

@@ -1,23 +0,0 @@
-[build-system]
-requires = ["setuptools>=61.0", "wheel"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "dwani"
-version = "0.1.2"
-description = "Multimodal AI server for Indian languages (speech, vision, LLMs, TTS, ASR, etc.)"
-authors = [
-    { name="sachin", email="python@dwani.ai" }
-]
-readme = "README.md"
-license = { file = "LICENSE" }
-requires-python = ">=3.10"
-
-dependencies = [
-    "requests>=2.25.0",
-]
-
-[project.urls]
-Homepage = "https://github.com/dwani-ai/dwani-server"
-Source = "https://github.com/dwani-ai/dwani-server"
-Issues = "https://github.com/dwani-ai/dwani-server/issues"