dwani 0.1.8__tar.gz → 0.1.10__tar.gz

{dwani-0.1.8 → dwani-0.1.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dwani
-Version: 0.1.8
+Version: 0.1.10
 Summary: Multimodal API for Indian languages (Chat, Vision, TTS, ASR, Translate, Docs)
 Author-email: sachin <python@dwani.ai>
 License: MIT License
@@ -55,33 +55,44 @@ dwani.api_key = os.getenv("DWANI_API_KEY")
 dwani.api_base = os.getenv("DWANI_API_BASE_URL")
 ```
 
-### Examples
 
-#### Text Query 
+### Text Query 
+---
+- With model selection
+  - Supported models : gemma3 (default), qwen3, deepseek-r1-8b, sarvam-m
+
+---
+- gemma3
 ```python
-resp = dwani.Chat.create(prompt="Hello!", src_lang="english", tgt_lang="kannada")
+resp = dwani.Chat.create(prompt="Hello!", src_lang="english", tgt_lang="kannada", model="gemma3")
 print(resp)
 ```
 ```json
 {'response': 'ನಮಸ್ತೆ! ಭಾರತ ಮತ್ತು ಕರ್ನಾಟಕವನ್ನು ಗಮನದಲ್ಲಿಟ್ಟುಕೊಂಡು ಇಂದು ನಿಮ್ಮ ಪ್ರಶ್ನೆಗಳಿಗೆ ನಾನು ನಿಮಗೆ ಹೇಗೆ ಸಹಾಯ ಮಾಡಲಿ?'}
 ```
+---
+### Vision Query
+---
+- With model selection
+  - Supported models : gemma3 (default), moondream
+- gemma3
 
-
-#### Vision Query
 ```python
 result = dwani.Vision.caption(
     file_path="image.png",
     query="Describe this logo",
     src_lang="english",
-    tgt_lang="kannada"
+    tgt_lang="kannada",
+    model="gemma3"
 )
 print(result)
 ```
 ```json
 {'answer': 'ಒಂದು ವಾಕ್ಯದಲ್ಲಿ ಚಿತ್ರದ ಸಾರಾಂಶವನ್ನು ಇಲ್ಲಿ ನೀಡಲಾಗಿದೆಃ ಪ್ರಕಟಣೆಯ ಅವಲೋಕನವು ಪ್ರಸ್ತುತ ಅರವತ್ತನಾಲ್ಕು ದೇಶಗಳು/ಪ್ರದೇಶಗಳನ್ನು ಸೇರಿಸಲಾಗಿದೆ ಮತ್ತು ಇನ್ನೂ ಹದಿನಾರು ಪ್ರದೇಶಗಳನ್ನು ಸೇರಿಸಬೇಕಾಗಿದೆ. ಒದಗಿಸಲಾದ ಚಿತ್ರದಲ್ಲಿ ಲಾಂಛನವು ಕಾಣಿಸುವುದಿಲ್ಲ.'}
 ```
-
-#### Speech to Text -  Automatic Speech Recognition (ASR)
+---
+### Speech to Text -  Automatic Speech Recognition (ASR)
+---
 ```python
 result = dwani.ASR.transcribe(file_path="kannada_sample.wav", language="kannada")
 print(result)
@@ -89,20 +100,22 @@ print(result)
 ```json
 {'text': 'ಕರ್ನಾಟಕ ದ ರಾಜಧಾನಿ ಯಾವುದು'}
 ```
-
+---
 ### Translate
+---
 ```python
-resp = dwani.Translate.run_translate(sentences=["hi"], src_lang="english", tgt_lang="kannada")
+resp = dwani.Translate.run_translate(sentences="hi, i am gaganyatri", src_lang="english", tgt_lang="kannada")
 print(resp)
 ```
 ```json
 {'translations': ['ಹಾಯ್']}
 ```
-#### Text to Speech -  Speech Synthesis
-
+---
+### Text to Speech -  Speech Synthesis
+---
 ```python
-response = dwani.Audio.speech(input="ಕರ್ನಾಟಕ ದ ರಾಜಧಾನಿ ಯಾವುದು", response_format="mp3")
-with open("output.mp3", "wb") as f:
+response = dwani.Audio.speech(input="ಕರ್ನಾಟಕ ದ ರಾಜಧಾನಿ ಯಾವುದು", response_format="wav")
+with open("output.wav", "wb") as f:
     f.write(response)
 ```
 

{dwani-0.1.8 → dwani-0.1.10}/README.md

@@ -19,33 +19,44 @@ dwani.api_key = os.getenv("DWANI_API_KEY")
 dwani.api_base = os.getenv("DWANI_API_BASE_URL")
 ```
 
-### Examples
 
-#### Text Query 
+### Text Query 
+---
+- With model selection
+  - Supported models : gemma3 (default), qwen3, deepseek-r1-8b, sarvam-m
+
+---
+- gemma3
 ```python
-resp = dwani.Chat.create(prompt="Hello!", src_lang="english", tgt_lang="kannada")
+resp = dwani.Chat.create(prompt="Hello!", src_lang="english", tgt_lang="kannada", model="gemma3")
 print(resp)
 ```
 ```json
 {'response': 'ನಮಸ್ತೆ! ಭಾರತ ಮತ್ತು ಕರ್ನಾಟಕವನ್ನು ಗಮನದಲ್ಲಿಟ್ಟುಕೊಂಡು ಇಂದು ನಿಮ್ಮ ಪ್ರಶ್ನೆಗಳಿಗೆ ನಾನು ನಿಮಗೆ ಹೇಗೆ ಸಹಾಯ ಮಾಡಲಿ?'}
 ```
+---
+### Vision Query
+---
+- With model selection
+  - Supported models : gemma3 (default), moondream
+- gemma3
 
-
-#### Vision Query
 ```python
 result = dwani.Vision.caption(
     file_path="image.png",
     query="Describe this logo",
     src_lang="english",
-    tgt_lang="kannada"
+    tgt_lang="kannada",
+    model="gemma3"
 )
 print(result)
 ```
 ```json
 {'answer': 'ಒಂದು ವಾಕ್ಯದಲ್ಲಿ ಚಿತ್ರದ ಸಾರಾಂಶವನ್ನು ಇಲ್ಲಿ ನೀಡಲಾಗಿದೆಃ ಪ್ರಕಟಣೆಯ ಅವಲೋಕನವು ಪ್ರಸ್ತುತ ಅರವತ್ತನಾಲ್ಕು ದೇಶಗಳು/ಪ್ರದೇಶಗಳನ್ನು ಸೇರಿಸಲಾಗಿದೆ ಮತ್ತು ಇನ್ನೂ ಹದಿನಾರು ಪ್ರದೇಶಗಳನ್ನು ಸೇರಿಸಬೇಕಾಗಿದೆ. ಒದಗಿಸಲಾದ ಚಿತ್ರದಲ್ಲಿ ಲಾಂಛನವು ಕಾಣಿಸುವುದಿಲ್ಲ.'}
 ```
-
-#### Speech to Text -  Automatic Speech Recognition (ASR)
+---
+### Speech to Text -  Automatic Speech Recognition (ASR)
+---
 ```python
 result = dwani.ASR.transcribe(file_path="kannada_sample.wav", language="kannada")
 print(result)
@@ -53,20 +64,22 @@ print(result)
 ```json
 {'text': 'ಕರ್ನಾಟಕ ದ ರಾಜಧಾನಿ ಯಾವುದು'}
 ```
-
+---
 ### Translate
+---
 ```python
-resp = dwani.Translate.run_translate(sentences=["hi"], src_lang="english", tgt_lang="kannada")
+resp = dwani.Translate.run_translate(sentences="hi, i am gaganyatri", src_lang="english", tgt_lang="kannada")
 print(resp)
 ```
 ```json
 {'translations': ['ಹಾಯ್']}
 ```
-#### Text to Speech -  Speech Synthesis
-
+---
+### Text to Speech -  Speech Synthesis
+---
 ```python
-response = dwani.Audio.speech(input="ಕರ್ನಾಟಕ ದ ರಾಜಧಾನಿ ಯಾವುದು", response_format="mp3")
-with open("output.mp3", "wb") as f:
+response = dwani.Audio.speech(input="ಕರ್ನಾಟಕ ದ ರಾಜಧಾನಿ ಯಾವುದು", response_format="wav")
+with open("output.wav", "wb") as f:
     f.write(response)
 ```
 

dwani-0.1.10/dwani/__init__.py

@@ -0,0 +1,67 @@
+from .client import DwaniClient
+from .chat import Chat
+from .audio import Audio
+from .vision import Vision
+from .asr import ASR
+from .translate import Translate
+from .exceptions import DwaniAPIError
+from .docs import Documents
+
+__all__ = ["DwaniClient", "Chat", "Audio", "Vision", "ASR", "DwaniAPIError", "Translate", "Documents"]
+
+# Optionally, instantiate a default client for convenience
+api_key = None
+api_base = "http://0.0.0.0:8000"
+
+def _get_client():
+    global _client
+    if "_client" not in globals() or _client is None:
+        from .client import DwaniClient
+        globals()["_client"] = DwaniClient(api_key=api_key, api_base=api_base)
+    return _client
+
+class chat:
+    @staticmethod
+    def create(prompt, src_lang, tgt_lang, model="gemma3"):
+        return _get_client().chat(prompt, src_lang, tgt_lang, model)
+
+class audio:
+    @staticmethod
+    def speech(input, response_format="wav"):
+        return _get_client().speech(input, response_format)
+
+class vision:
+    @staticmethod
+    def caption(file_path, query="describe the image", src_lang="eng_Latn", tgt_lang="kan_Knda", model="gemma3"):
+        return _get_client().caption(file_path, query, src_lang, tgt_lang, model)
+
+class asr:
+    @staticmethod
+    def transcribe(file_path, language="kannada"):
+        return _get_client().transcribe(file_path, language)
+
+class translate:
+    @staticmethod
+    def run_translate(sentences, src_lang="kan_Knda", tgt_lang="eng_Latn"):
+        return _get_client().translate(sentences, src_lang, tgt_lang)
+
+class document:
+    @staticmethod
+    def run_ocr(file_path, language="eng_Latn", model="gemma3"):
+        return _get_client().document_ocr(file_path, language, model)
+    
+    @staticmethod
+    def run_summarize(file_path, page_number=1, src_lang="eng_Latn", tgt_lang="kan_Knda", model="gemma3"):
+        return _get_client().document_summarize(file_path, page_number, src_lang, tgt_lang, model)
+    
+    @staticmethod
+    def run_extract(file_path, page_number=1, src_lang="eng_Latn", tgt_lang="kan_Knda", model="gemma3"):
+        return _get_client().extract(file_path, page_number, src_lang, tgt_lang, model)
+    
+    @staticmethod
+    def run_doc_query(file_path, page_number=1, prompt="list the key points", src_lang="eng_Latn", tgt_lang="kan_Knda", model="gemma3"):
+        return _get_client().doc_query(file_path, page_number, prompt, src_lang, tgt_lang, model)
+    
+    @staticmethod
+    def run_doc_query_kannada(file_path, page_number=1, prompt="list key points", src_lang="eng_Latn", tgt_lang="kan_Knda", model="gemma3"):
+        return _get_client().doc_query_kannada(file_path, page_number, prompt, src_lang, tgt_lang, model)

{dwani-0.1.8 → dwani-0.1.10}/dwani/asr.py

@@ -1,4 +1,4 @@
-from .exceptions import DhwaniAPIError
+from .exceptions import DwaniAPIError
 import requests
 
 # Allowed languages (case-sensitive for display, but we'll handle case-insensitively)
@@ -45,7 +45,7 @@ def asr_transcribe(client, file_path, language):
             files=files
         )
     if resp.status_code != 200:
-        raise DhwaniAPIError(resp)
+        raise DwaniAPIError(resp)
     return resp.json()
 
 class ASR:

{dwani-0.1.8 → dwani-0.1.10}/dwani/audio.py

@@ -1,4 +1,4 @@
-from .exceptions import DhwaniAPIError
+from .exceptions import DwaniAPIError
 import requests
 
 def audio_speech(client, input, response_format="mp3", output_file=None):
@@ -14,7 +14,7 @@ def audio_speech(client, input, response_format="mp3", output_file=None):
         stream=True
     )
     if resp.status_code != 200:
-        raise DhwaniAPIError(resp)
+        raise DwaniAPIError(resp)
     if output_file:
         with open(output_file, "wb") as f:
             for chunk in resp.iter_content(chunk_size=8192):

{dwani-0.1.8 → dwani-0.1.10}/dwani/chat.py

@@ -1,4 +1,4 @@
-from .exceptions import DhwaniAPIError
+from .exceptions import DwaniAPIError
 import requests
 
 # Language options mapping
@@ -36,7 +36,12 @@ def normalize_language(lang):
     supported_langs = list(lang_name_to_code.keys()) + list(lang_code_to_code.keys())
     raise ValueError(f"Unsupported language: {lang}. Supported languages: {supported_langs}")
 
-def chat_create(client, prompt, src_lang, tgt_lang, **kwargs):
+def chat_create(client, prompt, src_lang, tgt_lang, model="gemma3"):
+    # Validate model
+    valid_models = ["gemma3", "qwen3", "deepseek-r1"]
+    if model not in valid_models:
+        raise ValueError(f"Unsupported model: {model}. Supported models: {valid_models}")
+    
     # Normalize source and target languages
     src_lang_code = normalize_language(src_lang)
     tgt_lang_code = normalize_language(tgt_lang)
@@ -45,20 +50,20 @@ def chat_create(client, prompt, src_lang, tgt_lang, **kwargs):
     payload = {
         "prompt": prompt,
         "src_lang": src_lang_code,
-        "tgt_lang": tgt_lang_code
+        "tgt_lang": tgt_lang_code,
+        "model": model
     }
-    payload.update(kwargs)
     resp = requests.post(
         url,
         headers={**client._headers(), "Content-Type": "application/json"},
         json=payload
     )
     if resp.status_code != 200:
-        raise DhwaniAPIError(resp)
+        raise DwaniAPIError(resp)
     return resp.json()
 
 class Chat:
     @staticmethod
-    def create(prompt, src_lang, tgt_lang, **kwargs):
+    def create(prompt, src_lang, tgt_lang, model="gemma3"):
         from . import _get_client
-        return _get_client().chat(prompt, src_lang, tgt_lang, **kwargs)
+        return _get_client().chat(prompt, src_lang, tgt_lang, model)

{dwani-0.1.8 → dwani-0.1.10}/dwani/client.py

@@ -1,54 +1,56 @@
 import os
 import requests
-from .exceptions import DhwaniAPIError
+from .exceptions import DwaniAPIError
 
-class DhwaniClient:
+class DwaniClient:
     def __init__(self, api_key=None, api_base=None):
         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:8000")
+        self.api_base = api_base or os.getenv("DWANI_API_BASE_URL", "http://0.0.0.0:8000")
         if not self.api_key:
-            raise ValueError("DHWANI_API_KEY not set")
+            raise ValueError("DWANI_API_KEY not set")
 
     def _headers(self):
-        return {"X-API-Key": self.api_key}
+        return {
+            "X-API-Key": self.api_key,
+            "Accept": "application/json"
+        }
 
-    def translate(self, sentences, src_lang, tgt_lang, **kwargs):
+    def translate(self, sentences, src_lang, tgt_lang):
         from .translate import run_translate
-        return run_translate(self, sentences=sentences, src_lang=src_lang, tgt_lang=tgt_lang, **kwargs)
+        return run_translate(self, sentences=sentences, src_lang=src_lang, tgt_lang=tgt_lang)
 
-    def chat(self, prompt, src_lang, tgt_lang, **kwargs):
+    def chat(self, prompt, src_lang, tgt_lang, model="gemma3"):
         from .chat import chat_create
-        return chat_create(self, prompt=prompt, src_lang=src_lang, tgt_lang=tgt_lang, **kwargs)
+        return chat_create(self, prompt=prompt, src_lang=src_lang, tgt_lang=tgt_lang, model=model)
     
-    def speech(self, input, response_format="mp3", **kwargs):
+    def speech(self, input, response_format="mp3"):
         from .audio import audio_speech
-        return audio_speech(self, input=input, response_format=response_format, **kwargs)
+        return audio_speech(self, input=input, response_format=response_format)
 
-    def caption(self, file_path, query="describe the image", src_lang="eng_Latn", tgt_lang="kan_Knda", **kwargs):
+    def caption(self, file_path, query="describe the image", src_lang="eng_Latn", tgt_lang="kan_Knda", model="gemma3"):
         from .vision import vision_caption
-        return vision_caption(self, file_path=file_path, query=query, src_lang=src_lang, tgt_lang=tgt_lang, **kwargs)
+        return vision_caption(self, file_path=file_path, query=query, src_lang=src_lang, tgt_lang=tgt_lang, model=model)
 
-    def transcribe(self, file_path, language=None, **kwargs):
+    def transcribe(self, file_path, language=None):
         from .asr import asr_transcribe
-        return asr_transcribe(self, file_path=file_path, language=language, **kwargs)
+        return asr_transcribe(self, file_path=file_path, language=language)
     
-    def document_ocr(self, file_path, language=None, **kwargs):
+    def document_ocr(self, file_path, language=None, model="gemma3"):
         from .docs import document_ocr
-        return document_ocr(self, file_path=file_path, language=language, **kwargs)
+        return document_ocr(self, file_path=file_path, language=language, model=model)
 
-    def document_summarize(self, file_path, page_number=1, src_lang="eng_Latn", tgt_lang="kan_Knda", **kwargs):
+    def document_summarize(self, file_path, page_number=1, src_lang="eng_Latn", tgt_lang="kan_Knda", model="gemma3"):
         from .docs import document_summarize
-        return document_summarize(self, file_path, page_number, src_lang, tgt_lang, **kwargs)
+        return document_summarize(self, file_path, page_number, src_lang, tgt_lang, model)
 
-    def extract(self, file_path, page_number=1, src_lang="eng_Latn", tgt_lang="kan_Knda", **kwargs):
+    def extract(self, file_path, page_number=1, src_lang="eng_Latn", tgt_lang="kan_Knda", model="gemma3"):
         from .docs import extract
-        return extract(self, file_path=file_path, page_number=page_number, src_lang=src_lang,tgt_lang=tgt_lang, **kwargs)
+        return extract(self, file_path=file_path, page_number=page_number, src_lang=src_lang, tgt_lang=tgt_lang, model=model)
 
-
-    def doc_query( self, file_path, page_number=1, prompt="list the key points", src_lang="eng_Latn", tgt_lang="kan_Knda" , **kwargs ):
+    def doc_query(self, file_path, page_number=1, prompt="list the key points", src_lang="eng_Latn", tgt_lang="kan_Knda", model="gemma3"):
         from .docs import doc_query
-        return doc_query( self, file_path, page_number=page_number, prompt=prompt, src_lang=src_lang, tgt_lang=tgt_lang , **kwargs )
+        return doc_query(self, file_path, page_number=page_number, prompt=prompt, src_lang=src_lang, tgt_lang=tgt_lang, model=model)
 
-    def doc_query_kannada(self, file_path, page_number=1, prompt="list key points", src_lang="eng_Latn", language=None, **kwargs):
+    def doc_query_kannada(self, file_path, page_number=1, prompt="list key points", src_lang="eng_Latn", language="kan_Knda", model="gemma3"):
         from .docs import doc_query_kannada
-        return doc_query_kannada(self, file_path=file_path, page_number=page_number, prompt=prompt, src_lang=src_lang, language=language, **kwargs)
+        return doc_query_kannada(self, file_path=file_path, page_number=page_number, prompt=prompt, src_lang=src_lang, language=language, model=model)

dwani-0.1.10/dwani/docs.py

@@ -0,0 +1,286 @@
+import requests
+
+from .exceptions import DwaniAPIError
+import logging
+
+# Set up logging
+logger = logging.getLogger(__name__)
+
+# Language options mapping (aligned with server’s SUPPORTED_LANGUAGES)
+language_options = [
+    ("English", "eng_Latn"),
+    ("Kannada", "kan_Knda"),
+    ("Hindi", "hin_Deva"),
+    ("Tamil", "tam_Taml"),
+    ("Telugu", "tel_Telu"),
+    ("German", "deu_Latn") 
+]
+
+# Create dictionaries for language name to code and code to code mapping
+lang_name_to_code = {name.lower(): code for name, code in language_options}
+lang_code_to_code = {code: code for _, code in language_options}
+
+# Supported models (aligned with server)
+VALID_MODELS = ["gemma3", "moondream", "qwen2.5vl", "qwen3", "sarvam-m", "deepseek-r1"]
+
+def normalize_language(lang):
+    """Convert language input (name or code) to language code."""
+    lang = lang.strip()
+    lang_lower = lang.lower()
+    if lang_lower in lang_name_to_code:
+        return lang_name_to_code[lang_lower]
+    if lang in lang_code_to_code:
+        return lang_code_to_code[lang]
+    supported_langs = list(lang_name_to_code.keys()) + list(lang_code_to_code.keys())
+    raise ValueError(f"Unsupported language: {lang}. Supported languages: {supported_langs}")
+
+def validate_model(model):
+    """Validate the model against supported models."""
+    if model not in VALID_MODELS:
+        raise ValueError(f"Unsupported model: {model}. Supported models: {VALID_MODELS}")
+    return model
+
+def document_ocr(client, file_path, language=None, model="gemma3"):
+    """OCR a document (image/PDF) and return extracted text."""
+    logger.debug(f"Calling document_ocr: file_path={file_path}, language={language}, model={model}")
+    validate_model(model)
+    
+    data = {"model": model}
+    if language:
+        data["language"] = normalize_language(language)
+    
+    with open(file_path, "rb") as f:
+        mime_type = "application/pdf" if file_path.lower().endswith('.pdf') else "image/png"
+        files = {"file": (file_path, f, mime_type)}
+        try:
+            resp = requests.post(
+                f"{client.api_base}/v1/document/ocr",
+                headers=client._headers(),
+                files=files,
+                data=data,
+                timeout=60
+            )
+            resp.raise_for_status()
+        except requests.RequestException as e:
+            logger.error(f"OCR request failed: {str(e)}")
+            raise DwaniAPIError(resp) if 'resp' in locals() else DwaniAPIError.from_exception(e)
+    
+    logger.debug(f"OCR response: {resp.status_code}")
+    return resp.json()
+
+def document_summarize(client, file_path, page_number=1, src_lang="eng_Latn", tgt_lang="kan_Knda", model="gemma3"):
+    """Summarize a PDF document with language and page number options."""
+    logger.debug(f"Calling document_summarize: file_path={file_path}, page_number={page_number}, src_lang={src_lang}, tgt_lang={tgt_lang}, model={model}")
+    validate_model(model)
+    
+    if not file_path.lower().endswith('.pdf'):
+        raise ValueError("File must be a PDF")
+    if page_number < 1:
+        raise ValueError("Page number must be at least 1")
+    
+    src_lang_code = normalize_language(src_lang)
+    tgt_lang_code = normalize_language(tgt_lang)
+    
+    url = f"{client.api_base}/v1/indic-summarize-pdf"
+    headers = client._headers()
+    with open(file_path, "rb") as f:
+        files = {"file": (file_path, f, "application/pdf")}
+        data = {
+            "page_number": str(page_number),
+            "src_lang": src_lang_code,
+            "tgt_lang": tgt_lang_code,
+            "model": model
+        }
+
+        try:
+            resp = requests.post(
+                url,
+                headers=headers,
+                files=files,
+                data=data,
+                timeout=60
+            )
+            resp.raise_for_status()
+        except requests.RequestException as e:
+            logger.error(f"Summarize request failed: {str(e)}")
+            raise DwaniAPIError(resp) if 'resp' in locals() else DwaniAPIError.from_exception(e)
+    
+    logger.debug(f"Summarize response: {resp.status_code}")
+
+    return resp.json()
+
+def extract(client, file_path, page_number=1, src_lang="eng_Latn", tgt_lang="kan_Knda", model="gemma3"):
+    """Extract and translate text from a PDF document using form data."""
+    logger.debug(f"Calling extract: file_path={file_path}, page_number={page_number}, src_lang={src_lang}, tgt_lang={tgt_lang}, model={model}")
+    validate_model(model)
+    
+    if not file_path.lower().endswith('.pdf'):
+        raise ValueError("File must be a PDF")
+    if page_number < 1:
+        raise ValueError("Page number must be at least 1")
+    
+    src_lang_code = normalize_language(src_lang)
+    tgt_lang_code = normalize_language(tgt_lang)
+    
+    url = f"{client.api_base}/v1/indic-extract-text/"
+    headers = client._headers()
+    with open(file_path, "rb") as f:
+        files = {"file": (file_path, f, "application/pdf")}
+
+        data = {
+            "page_number": str(page_number),
+            "src_lang": src_lang_code,
+            "tgt_lang": tgt_lang_code,
+            "model": model
+        }
+        try:
+            resp = requests.post(
+                url,
+                headers=headers,
+                files=files,
+                data=data,
+                timeout=60
+            )
+            resp.raise_for_status()
+        except requests.RequestException as e:
+            logger.error(f"Extract request failed: {str(e)}")
+            raise DwaniAPIError(resp) if 'resp' in locals() else DwaniAPIError.from_exception(e)
+    
+    logger.debug(f"Extract response: {resp.status_code}")
+
+    return resp.json()
+
+def doc_query(
+    client,
+    file_path,
+    page_number=1,
+    prompt="list the key points",
+    src_lang="eng_Latn",
+    tgt_lang="kan_Knda",
+    model="gemma3"
+):
+    """Query a document with a custom prompt and language options."""
+    logger.debug(f"Calling doc_query: file_path={file_path}, page_number={page_number}, prompt={prompt}, src_lang={src_lang}, tgt_lang={tgt_lang}, model={model}")
+    validate_model(model)
+    
+    if not file_path.lower().endswith('.pdf'):
+        raise ValueError("File must be a PDF")
+    if page_number < 1:
+        raise ValueError("Page number must be at least 1")
+    if not prompt.strip():
+        raise ValueError("Prompt cannot be empty")
+    
+    src_lang_code = normalize_language(src_lang)
+    tgt_lang_code = normalize_language(tgt_lang)
+    
+    url = f"{client.api_base}/v1/indic-custom-prompt-pdf"
+    headers = client._headers()
+    with open(file_path, "rb") as f:
+        files = {"file": (file_path, f, "application/pdf")}
+        data = {
+            "page_number": str(page_number),
+            "prompt": prompt,
+            "src_lang": src_lang_code,
+            "tgt_lang": tgt_lang_code,
+            "model": model
+        }
+
+        try:
+            resp = requests.post(
+                url,
+                headers=headers,
+                files=files,
+                data=data,
+                timeout=60
+            )
+            resp.raise_for_status()
+        except requests.RequestException as e:
+            logger.error(f"Doc query request failed: {str(e)}")
+            raise DwaniAPIError(resp) if 'resp' in locals() else DwaniAPIError.from_exception(e)
+    
+    logger.debug(f"Doc query response: {resp.status_code}")
+
+    return resp.json()
+
+def doc_query_kannada(
+    client,
+    file_path,
+    page_number=1,
+    prompt="list key points",
+    src_lang="eng_Latn",
+    tgt_lang="kan_Knda",
+    model="gemma3"
+):
+    """Query a document with a custom prompt, outputting in Kannada."""
+    logger.debug(f"Calling doc_query_kannada: file_path={file_path}, page_number={page_number}, prompt={prompt}, src_lang={src_lang}, tgt_lang={tgt_lang}, model={model}")
+    validate_model(model)
+    
+    if not file_path.lower().endswith('.pdf'):
+        raise ValueError("File must be a PDF")
+    if page_number < 1:
+        raise ValueError("Page number must be at least 1")
+    if not prompt.strip():
+        raise ValueError("Prompt cannot be empty")
+    
+    src_lang_code = normalize_language(src_lang)
+    tgt_lang_code = normalize_language(tgt_lang) if tgt_lang else "kan_Knda"
+    
+    url = f"{client.api_base}/v1/indic-custom-prompt-pdf"
+    headers = client._headers()
+    with open(file_path, "rb") as f:
+        files = {"file": (file_path, f, "application/pdf")}
+
+        data = {
+            "page_number": str(page_number),
+            "prompt": prompt,
+            "src_lang": src_lang_code,
+            "tgt_lang": tgt_lang_code,
+            "model": model
+        }
+        try:
+            resp = requests.post(
+                url,
+                headers=headers,
+                files=files,
+                data=data,
+                timeout=60
+            )
+            resp.raise_for_status()
+        except requests.RequestException as e:
+            logger.error(f"Doc query Kannada request failed: {str(e)}")
+            raise DwaniAPIError(resp) if 'resp' in locals() else DwaniAPIError.from_exception(e)
+    
+    logger.debug(f"Doc query Kannada response: {resp.status_code}")
+
+    return resp.json()
+
+class Documents:
+    @staticmethod
+    def ocr(file_path, language=None, model="gemma3"):
+        from .client import DwaniClient
+        client = DwaniClient()
+        return document_ocr(client, file_path, language, model)
+    
+    @staticmethod
+    def summarize(file_path, page_number=1, src_lang="eng_Latn", tgt_lang="kan_Knda", model="gemma3"):
+        from .client import DwaniClient
+        client = DwaniClient()
+        return document_summarize(client, file_path, page_number, src_lang, tgt_lang, model)
+    
+    @staticmethod
+    def run_extract(file_path, page_number=1, src_lang="eng_Latn", tgt_lang="kan_Knda", model="gemma3"):
+        from .client import DwaniClient
+        client = DwaniClient()
+        return extract(client, file_path, page_number, src_lang, tgt_lang, model)
+    
+    @staticmethod
+    def run_doc_query(file_path, page_number=1, prompt="list the key points", src_lang="eng_Latn", tgt_lang="kan_Knda", model="gemma3"):
+        from .client import DwaniClient
+        client = DwaniClient()
+        return doc_query(client, file_path, page_number, prompt, src_lang, tgt_lang, model)
+    
+    @staticmethod
+    def run_doc_query_kannada(file_path, page_number=1, prompt="list key points", src_lang="eng_Latn", tgt_lang="kan_Knda", model="gemma3"):
+        from .client import DwaniClient
+        client = DwaniClient()
+        return doc_query_kannada(client, file_path, page_number, prompt, src_lang, tgt_lang, model)

{dwani-0.1.8 → dwani-0.1.10}/dwani/exceptions.py

@@ -1,4 +1,4 @@
-class DhwaniAPIError(Exception):
+class DwaniAPIError(Exception):
     def __init__(self, response):
         super().__init__(f"API Error {response.status_code}: {response.text}")
         self.status_code = response.status_code

{dwani-0.1.8 → dwani-0.1.10}/dwani/translate.py

@@ -1,4 +1,4 @@
-from .exceptions import DhwaniAPIError
+from .exceptions import DwaniAPIError
 import requests
 
 # Language options mapping
@@ -36,7 +36,17 @@ def normalize_language(lang):
     supported_langs = list(lang_name_to_code.keys()) + list(lang_code_to_code.keys())
     raise ValueError(f"Unsupported language: {lang}. Supported languages: {supported_langs}")
 
-def run_translate(client, sentences, src_lang, tgt_lang, **kwargs):
+def run_translate(client, sentences, src_lang, tgt_lang):
+    # Convert single string to list if necessary
+    if isinstance(sentences, str):
+        sentences = [sentences]
+    elif not isinstance(sentences, list):
+        raise ValueError("sentences must be a string or a list of strings")
+    
+    # Validate that all elements in the list are strings
+    if not all(isinstance(s, str) for s in sentences):
+        raise ValueError("All sentences must be strings")
+    
     # Normalize source and target languages
     src_lang_code = normalize_language(src_lang)
     tgt_lang_code = normalize_language(tgt_lang)
@@ -47,18 +57,17 @@ def run_translate(client, sentences, src_lang, tgt_lang, **kwargs):
         "src_lang": src_lang_code,
         "tgt_lang": tgt_lang_code
     }
-    payload.update(kwargs)
     resp = requests.post(
         url,
         headers={**client._headers(), "Content-Type": "application/json", "accept": "application/json"},
         json=payload
     )
     if resp.status_code != 200:
-        raise DhwaniAPIError(resp)
+        raise DwaniAPIError(resp)
     return resp.json()
 
 class Translate:
     @staticmethod
-    def run_translate(sentences, src_lang, tgt_lang, **kwargs):
+    def run_translate(sentences, src_lang, tgt_lang):
         from . import _get_client
-        return _get_client().translate(sentences, src_lang, tgt_lang, **kwargs)
+        return _get_client().translate(sentences, src_lang, tgt_lang)

{dwani-0.1.8 → dwani-0.1.10}/dwani/vision.py

@@ -1,4 +1,4 @@
-from .exceptions import DhwaniAPIError
+from .exceptions import DwaniAPIError
 import requests
 
 # Language options mapping
@@ -36,7 +36,12 @@ def normalize_language(lang):
     supported_langs = list(lang_name_to_code.keys()) + list(lang_code_to_code.keys())
     raise ValueError(f"Unsupported language: {lang}. Supported languages: {supported_langs}")
 
-def vision_caption(client, file_path, query="describe the image", src_lang="eng_Latn", tgt_lang="kan_Knda"):
+def vision_caption(client, file_path, query="describe the image", src_lang="eng_Latn", tgt_lang="kan_Knda", model="gemma3"):
+    # Validate model
+    valid_models = ["gemma3", "qwen2.5vl", "moondream"]
+    if model not in valid_models:
+        raise ValueError(f"Unsupported model: {model}. Supported models: {valid_models}")
+    
     # Normalize source and target languages
     src_lang_code = normalize_language(src_lang)
     tgt_lang_code = normalize_language(tgt_lang)
@@ -44,7 +49,7 @@ def vision_caption(client, file_path, query="describe the image", src_lang="eng_
     # Build the endpoint using the client's api_base
     url = (
         f"{client.api_base}/v1/indic_visual_query"
-        f"?src_lang={src_lang_code}&tgt_lang={tgt_lang_code}"
+        f"?src_lang={src_lang_code}&tgt_lang={tgt_lang_code}&model={model}"
     )
     headers = {
         **client._headers(),
@@ -60,11 +65,11 @@ def vision_caption(client, file_path, query="describe the image", src_lang="eng_
             data=data
         )
     if resp.status_code != 200:
-        raise DhwaniAPIError(resp)
+        raise DwaniAPIError(resp)
     return resp.json()
 
 class Vision:
     @staticmethod
-    def caption(*args, **kwargs):
+    def caption(file_path, query="describe the image", src_lang="eng_Latn", tgt_lang="kan_Knda", model="gemma3"):
         from . import _get_client
-        return _get_client().caption(*args, **kwargs)
+        return _get_client().caption(file_path, query, src_lang, tgt_lang, model)

{dwani-0.1.8 → dwani-0.1.10}/dwani.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dwani
-Version: 0.1.8
+Version: 0.1.10
 Summary: Multimodal API for Indian languages (Chat, Vision, TTS, ASR, Translate, Docs)
 Author-email: sachin <python@dwani.ai>
 License: MIT License
@@ -55,33 +55,44 @@ dwani.api_key = os.getenv("DWANI_API_KEY")
 dwani.api_base = os.getenv("DWANI_API_BASE_URL")
 ```
 
-### Examples
 
-#### Text Query 
+### Text Query 
+---
+- With model selection
+  - Supported models : gemma3 (default), qwen3, deepseek-r1-8b, sarvam-m
+
+---
+- gemma3
 ```python
-resp = dwani.Chat.create(prompt="Hello!", src_lang="english", tgt_lang="kannada")
+resp = dwani.Chat.create(prompt="Hello!", src_lang="english", tgt_lang="kannada", model="gemma3")
 print(resp)
 ```
 ```json
 {'response': 'ನಮಸ್ತೆ! ಭಾರತ ಮತ್ತು ಕರ್ನಾಟಕವನ್ನು ಗಮನದಲ್ಲಿಟ್ಟುಕೊಂಡು ಇಂದು ನಿಮ್ಮ ಪ್ರಶ್ನೆಗಳಿಗೆ ನಾನು ನಿಮಗೆ ಹೇಗೆ ಸಹಾಯ ಮಾಡಲಿ?'}
 ```
+---
+### Vision Query
+---
+- With model selection
+  - Supported models : gemma3 (default), moondream
+- gemma3
 
-
-#### Vision Query
 ```python
 result = dwani.Vision.caption(
     file_path="image.png",
     query="Describe this logo",
     src_lang="english",
-    tgt_lang="kannada"
+    tgt_lang="kannada",
+    model="gemma3"
 )
 print(result)
 ```
 ```json
 {'answer': 'ಒಂದು ವಾಕ್ಯದಲ್ಲಿ ಚಿತ್ರದ ಸಾರಾಂಶವನ್ನು ಇಲ್ಲಿ ನೀಡಲಾಗಿದೆಃ ಪ್ರಕಟಣೆಯ ಅವಲೋಕನವು ಪ್ರಸ್ತುತ ಅರವತ್ತನಾಲ್ಕು ದೇಶಗಳು/ಪ್ರದೇಶಗಳನ್ನು ಸೇರಿಸಲಾಗಿದೆ ಮತ್ತು ಇನ್ನೂ ಹದಿನಾರು ಪ್ರದೇಶಗಳನ್ನು ಸೇರಿಸಬೇಕಾಗಿದೆ. ಒದಗಿಸಲಾದ ಚಿತ್ರದಲ್ಲಿ ಲಾಂಛನವು ಕಾಣಿಸುವುದಿಲ್ಲ.'}
 ```
-
-#### Speech to Text -  Automatic Speech Recognition (ASR)
+---
+### Speech to Text -  Automatic Speech Recognition (ASR)
+---
 ```python
 result = dwani.ASR.transcribe(file_path="kannada_sample.wav", language="kannada")
 print(result)
@@ -89,20 +100,22 @@ print(result)
 ```json
 {'text': 'ಕರ್ನಾಟಕ ದ ರಾಜಧಾನಿ ಯಾವುದು'}
 ```
-
+---
 ### Translate
+---
 ```python
-resp = dwani.Translate.run_translate(sentences=["hi"], src_lang="english", tgt_lang="kannada")
+resp = dwani.Translate.run_translate(sentences="hi, i am gaganyatri", src_lang="english", tgt_lang="kannada")
 print(resp)
 ```
 ```json
 {'translations': ['ಹಾಯ್']}
 ```
-#### Text to Speech -  Speech Synthesis
-
+---
+### Text to Speech -  Speech Synthesis
+---
 ```python
-response = dwani.Audio.speech(input="ಕರ್ನಾಟಕ ದ ರಾಜಧಾನಿ ಯಾವುದು", response_format="mp3")
-with open("output.mp3", "wb") as f:
+response = dwani.Audio.speech(input="ಕರ್ನಾಟಕ ದ ರಾಜಧಾನಿ ಯಾವುದು", response_format="wav")
+with open("output.wav", "wb") as f:
     f.write(response)
 ```
 

{dwani-0.1.8 → dwani-0.1.10}/pyproject.toml

@@ -4,7 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dwani"
-version = "0.1.8"
+
+version = "0.1.10"
 description = "Multimodal API for Indian languages (Chat, Vision, TTS, ASR, Translate, Docs)"
 authors = [
     { name="sachin", email="python@dwani.ai" }

dwani-0.1.8/dwani/__init__.py

@@ -1,65 +0,0 @@
-from .client import DhwaniClient
-from .chat import Chat
-from .audio import Audio
-from .vision import Vision
-from .asr import ASR
-from .translate import Translate
-from .exceptions import DhwaniAPIError
-from .docs import Documents
-
-__all__ = ["DhwaniClient", "Chat", "Audio", "Vision", "ASR", "DhwaniAPIError", "Translate", "Documents"]
-
-# Optionally, instantiate a default client for convenience
-api_key = None
-api_base = "http://localhost:7860"
-
-def _get_client():
-    global _client
-    if "_client" not in globals() or _client is None:
-        from .client import DhwaniClient
-        globals()["_client"] = DhwaniClient(api_key=api_key, api_base=api_base)
-    return globals()["_client"]
-
-class chat:
-    @staticmethod
-    def create(prompt, **kwargs):
-        return _get_client().chat(prompt, **kwargs)
-
-class audio:
-    @staticmethod
-    def speech(*args, **kwargs):
-        return _get_client().speech(*args, **kwargs)
-
-class vision:
-    @staticmethod
-    def caption(*args, **kwargs):
-        return _get_client().caption(*args, **kwargs)
-
-class asr:
-    @staticmethod
-    def transcribe(*args, **kwargs):
-        return _get_client().transcribe(*args, **kwargs)
-
-
-class translate:
-    @staticmethod
-    def run_translate(*args, **kwargs):
-        return _get_client().translate(*args, **kwargs)
-    
-
-class document:
-    @staticmethod
-    def run_ocr(*args, **kwargs):
-        return _get_client().ocr(*args, **kwargs)
-    @staticmethod
-    def run_summarize(*args, **kwargs):
-        return _get_client().summarize(*args, **kwargs)
-    @staticmethod
-    def run_extract(*args, **kwargs):
-        return _get_client().extract(*args, **kwargs)
-    @staticmethod
-    def run_doc_query(*args, **kwargs):
-        return _get_client().doc_query(*args, **kwargs)
-    @staticmethod
-    def run_doc_query_kannada(*args, **kwargs):
-        return _get_client().doc_query_kannada(*args, **kwargs)

dwani-0.1.8/dwani/docs.py

@@ -1,198 +0,0 @@
-import requests
-from .exceptions import DhwaniAPIError
-
-# Language options mapping
-language_options = [
-    ("English", "eng_Latn"),
-    ("Kannada", "kan_Knda"),
-    ("Hindi", "hin_Deva"), 
-    ("Assamese", "asm_Beng"),
-    ("Bengali", "ben_Beng"),
-    ("Gujarati", "guj_Gujr"),
-    ("Malayalam", "mal_Mlym"),
-    ("Marathi", "mar_Deva"),
-    ("Odia", "ory_Orya"),
-    ("Punjabi", "pan_Guru"),
-    ("Tamil", "tam_Taml"),
-    ("Telugu", "tel_Telu"),
-    ("German", "deu_Latn") 
-]
-
-# Create dictionaries for language name to code and code to code mapping
-lang_name_to_code = {name.lower(): code for name, code in language_options}
-lang_code_to_code = {code: code for _, code in language_options}
-
-def normalize_language(lang):
-    """Convert language input (name or code) to language code."""
-    lang = lang.strip()
-    # Check if input is a language name (case-insensitive)
-    lang_lower = lang.lower()
-    if lang_lower in lang_name_to_code:
-        return lang_name_to_code[lang_lower]
-    # Check if input is a language code
-    if lang in lang_code_to_code:
-        return lang_code_to_code[lang]
-    # Raise error if language is not supported
-    supported_langs = list(lang_name_to_code.keys()) + list(lang_code_to_code.keys())
-    raise ValueError(f"Unsupported language: {lang}. Supported languages: {supported_langs}")
-
-def document_ocr(client, file_path, language=None):
-    """OCR a document (image/PDF) and return extracted text."""
-    data = {}
-    if language:
-        # Normalize the language input
-        data["language"] = normalize_language(language)
-    
-    with open(file_path, "rb") as f:
-        files = {"file": f}
-        resp = requests.post(
-            f"{client.api_base}/v1/document/ocr",
-            headers=client._headers(),
-            files=files,
-            data=data
-        )
-    if resp.status_code != 200:
-        raise DhwaniAPIError(resp)
-    return resp.json()
-
-def document_summarize(client, file_path, page_number=1, src_lang="eng_Latn", tgt_lang="kan_Knda"):
-    """Summarize a PDF document with language and page number options."""
-    # Normalize source and target languages
-    src_lang_code = normalize_language(src_lang)
-    tgt_lang_code = normalize_language(tgt_lang)
-    
-    url = f"{client.api_base}/v1/indic-summarize-pdf"
-    headers = client._headers()
-    with open(file_path, "rb") as f:
-        files = {"file": (file_path, f, "application/pdf")}
-        data = {
-            "page_number": str(page_number),
-            "src_lang": src_lang_code,
-            "tgt_lang": tgt_lang_code
-        }
-        resp = requests.post(
-            url,
-            headers=headers,
-            files=files,
-            data=data
-        )
-    if resp.status_code != 200:
-        raise DhwaniAPIError(resp)
-    return resp.json()
-
-def extract(client, file_path, page_number, src_lang, tgt_lang):
-    """
-    Extract and translate text from a document (image/PDF) using query parameters.
-    """
-    # Normalize source and target languages
-    src_lang_code = normalize_language(src_lang)
-    tgt_lang_code = normalize_language(tgt_lang)
-    
-    # Build the URL with query parameters
-    url = (
-        f"{client.api_base}/v1/indic-extract-text/"
-        f"?page_number={page_number}&src_lang={src_lang_code}&tgt_lang={tgt_lang_code}"
-    )
-    headers = client._headers()
-    with open(file_path, "rb") as f:
-        files = {"file": (file_path, f, "application/pdf")}
-        resp = requests.post(
-            url,
-            headers=headers,
-            files=files
-        )
-    if resp.status_code != 200:
-        raise DhwaniAPIError(resp)
-    return resp.json()
-
-def doc_query(
-    client,
-    file_path,
-    page_number=1,
-    prompt="list the key points",
-    src_lang="eng_Latn",
-    tgt_lang="kan_Knda"
-):
-    """Query a document with a custom prompt and language options."""
-    # Normalize source and target languages
-    src_lang_code = normalize_language(src_lang)
-    tgt_lang_code = normalize_language(tgt_lang)
-    
-    url = f"{client.api_base}/v1/indic-custom-prompt-pdf"
-    headers = client._headers()
-    with open(file_path, "rb") as f:
-        files = {"file": (file_path, f, "application/pdf")}
-        data = {
-            "page_number": str(page_number),
-            "prompt": prompt,
-            "source_language": src_lang_code,
-            "target_language": tgt_lang_code
-        }
-        resp = requests.post(
-            url,
-            headers=headers,
-            files=files,
-            data=data
-        )
-    if resp.status_code != 200:
-        raise DhwaniAPIError(resp)
-    return resp.json()
-
-def doc_query_kannada(
-    client, 
-    file_path, 
-    page_number=1, 
-    prompt="list key points", 
-    src_lang="eng_Latn",
-    language=None
-):
-    """Summarize a document (image/PDF/text) with custom prompt and language."""
-    # Normalize source language and optional language parameter
-    src_lang_code = normalize_language(src_lang)
-    data = {
-        "page_number": str(page_number),
-        "prompt": prompt,
-        "src_lang": src_lang_code,
-    }
-    if language:
-        data["language"] = normalize_language(language)
-    
-    url = f"{client.api_base}/v1/indic-custom-prompt-kannada-pdf"
-    headers = client._headers()
-    with open(file_path, "rb") as f:
-        files = {"file": (file_path, f, "application/pdf")}
-        resp = requests.post(
-            url,
-            headers=headers,
-            files=files,
-            data=data
-        )
-    if resp.status_code != 200:
-        raise DhwaniAPIError(resp)
-    return resp.json()
-
-class Documents:
-    @staticmethod
-    def ocr(file_path, language=None):
-        from . import _get_client
-        return _get_client().document_ocr(file_path, language)
-
-    @staticmethod
-    def summarize(*args, **kwargs):
-        from . import _get_client
-        return _get_client().document_summarize(*args, **kwargs)
-    
-    @staticmethod
-    def run_extract(*args, **kwargs):
-        from . import _get_client
-        return _get_client().extract(*args, **kwargs)
-    
-    @staticmethod
-    def run_doc_query(*args, **kwargs):
-        from . import _get_client
-        return _get_client().doc_query(*args, **kwargs)
-    
-    @staticmethod
-    def run_doc_query_kannada(*args, **kwargs):
-        from . import _get_client
-        return _get_client().doc_query_kannada(*args, **kwargs)