dwani 0.1.6__tar.gz → 0.1.7__tar.gz

{dwani-0.1.6 → dwani-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dwani
-Version: 0.1.6
+Version: 0.1.7
 Summary: Multimodal API for Indian languages (Chat, Vision, TTS, ASR, Translate, Docs)
 Author-email: sachin <python@dwani.ai>
 License: MIT License
@@ -42,6 +42,9 @@ Dynamic: license-file
 pip install dwani
 ```
 
+### Languages supported
+    - Assamese, Bengali, Gujarati, Hindi, Kannada, Malayalam, Marathi, Odia, Punjabi, Tamil, Telugu
+
 ### Setup the credentials
 ```python
 import dwani

{dwani-0.1.6 → dwani-0.1.7}/README.md

@@ -6,6 +6,9 @@
 pip install dwani
 ```
 
+### Languages supported
+    - Assamese, Bengali, Gujarati, Hindi, Kannada, Malayalam, Marathi, Odia, Punjabi, Tamil, Telugu
+
 ### Setup the credentials
 ```python
 import dwani

dwani-0.1.7/dwani/asr.py

@@ -0,0 +1,53 @@
+from .exceptions import DhwaniAPIError
+import requests
+
+# Allowed languages (case-sensitive for display, but we'll handle case-insensitively)
+ALLOWED_LANGUAGES = [
+    "Assamese",
+    "Bengali",
+    "Gujarati",
+    "Hindi",
+    "Kannada",
+    "Malayalam",
+    "Marathi",
+    "Odia",
+    "Punjabi",
+    "Tamil",
+    "Telugu"
+]
+
+def validate_language(language):
+    """Validate that the provided language is in the allowed list (case-insensitive)."""
+    # Create a case-insensitive mapping of allowed languages
+    language_map = {lang.lower(): lang for lang in ALLOWED_LANGUAGES}
+    # Check if the lowercase version of the input language is in the map
+    if language.lower() not in language_map:
+        raise ValueError(
+            f"Unsupported language: {language}. Supported languages: {ALLOWED_LANGUAGES}"
+        )
+    # Return the original case from ALLOWED_LANGUAGES for consistency
+    return language_map[language.lower()]
+
+def asr_transcribe(client, file_path, language):
+    # Validate the language input (case-insensitive)
+    validated_language = validate_language(language)
+    
+    # Convert language to lowercase for the API request
+    api_language = validated_language.lower()
+    
+    with open(file_path, "rb") as f:
+        files = {"file": f}
+        resp = requests.post(
+            f"{client.api_base}/v1/transcribe/?language={api_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)

dwani-0.1.7/dwani/chat.py

@@ -0,0 +1,63 @@
+from .exceptions import DhwaniAPIError
+import requests
+
+# 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") 
+]
+
+# Create a dictionary for language name 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 chat_create(client, prompt, src_lang, tgt_lang, **kwargs):
+    # 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_chat"
+    payload = {
+        "prompt": prompt,
+        "src_lang": src_lang_code,
+        "tgt_lang": tgt_lang_code
+    }
+    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.6 → dwani-0.1.7}/dwani/docs.py

@@ -1,13 +1,49 @@
 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") 
+]
+
+# 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}
-        data = {}
-        if language:
-            data["language"] = language
         resp = requests.post(
             f"{client.api_base}/v1/document/ocr",
             headers=client._headers(),
@@ -20,14 +56,18 @@ def document_ocr(client, file_path, language=None):
 
 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,
-            "tgt_lang": tgt_lang
+            "src_lang": src_lang_code,
+            "tgt_lang": tgt_lang_code
         }
         resp = requests.post(
             url,
@@ -39,18 +79,20 @@ def document_summarize(client, file_path, page_number=1, src_lang="eng_Latn", tg
         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}&tgt_lang={tgt_lang}"
+        f"?page_number={page_number}&src_lang={src_lang_code}&tgt_lang={tgt_lang_code}"
     )
     headers = client._headers()
-    # 'requests' handles multipart/form-data automatically
     with open(file_path, "rb") as f:
         files = {"file": (file_path, f, "application/pdf")}
         resp = requests.post(
@@ -71,6 +113,10 @@ def doc_query(
     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:
@@ -78,8 +124,8 @@ def doc_query(
         data = {
             "page_number": str(page_number),
             "prompt": prompt,
-            "source_language": src_lang,
-            "target_language": tgt_lang
+            "source_language": src_lang_code,
+            "target_language": tgt_lang_code
         }
         resp = requests.post(
             url,
@@ -91,7 +137,6 @@ def doc_query(
         raise DhwaniAPIError(resp)
     return resp.json()
 
-
 def doc_query_kannada(
     client, 
     file_path, 
@@ -101,18 +146,20 @@ def doc_query_kannada(
     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()
-    # 'requests' will handle multipart/form-data automatically
     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,
-        }
-        if language:
-            data["language"] = language
         resp = requests.post(
             url,
             headers=headers,
@@ -123,8 +170,6 @@ def doc_query_kannada(
         raise DhwaniAPIError(resp)
     return resp.json()
 
-
-
 class Documents:
     @staticmethod
     def ocr(file_path, language=None):
@@ -135,14 +180,17 @@ class Documents:
     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

dwani-0.1.7/dwani/translate.py

@@ -0,0 +1,63 @@
+from .exceptions import DhwaniAPIError
+import requests
+
+# 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") 
+]
+
+# 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 run_translate(client, sentences, src_lang, tgt_lang, **kwargs):
+    # 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/translate"
+    payload = {
+        "sentences": sentences,
+        "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)
+    return resp.json()
+
+class Translate:
+    @staticmethod
+    def run_translate(sentences, src_lang, tgt_lang, **kwargs):
+        from . import _get_client
+        return _get_client().translate(sentences, src_lang, tgt_lang, **kwargs)

dwani-0.1.7/dwani/vision.py

@@ -0,0 +1,69 @@
+from .exceptions import DhwaniAPIError
+import requests
+
+# 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") 
+]
+
+# 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 vision_caption(client, file_path, query="describe the image", src_lang="eng_Latn", tgt_lang="kan_Knda"):
+    # Normalize source and target languages
+    src_lang_code = normalize_language(src_lang)
+    tgt_lang_code = normalize_language(tgt_lang)
+    
+    # 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}"
+    )
+    headers = {
+        **client._headers(),
+        "accept": "application/json"
+    }
+    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.6 → dwani-0.1.7}/dwani.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dwani
-Version: 0.1.6
+Version: 0.1.7
 Summary: Multimodal API for Indian languages (Chat, Vision, TTS, ASR, Translate, Docs)
 Author-email: sachin <python@dwani.ai>
 License: MIT License
@@ -42,6 +42,9 @@ Dynamic: license-file
 pip install dwani
 ```
 
+### Languages supported
+    - Assamese, Bengali, Gujarati, Hindi, Kannada, Malayalam, Marathi, Odia, Punjabi, Tamil, Telugu
+
 ### Setup the credentials
 ```python
 import dwani

{dwani-0.1.6 → dwani-0.1.7}/pyproject.toml

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

dwani-0.1.6/dwani/asr.py

@@ -1,20 +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}/v1/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)
-

dwani-0.1.6/dwani/chat.py

@@ -1,25 +0,0 @@
-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.6/dwani/translate.py

@@ -1,26 +0,0 @@
-from .exceptions import DhwaniAPIError
-import requests
-
-def run_translate(client, sentences, src_lang, tgt_lang, **kwargs):
-    url = f"{client.api_base}/v1/translate"
-    payload = {
-        "sentences": sentences,
-        "src_lang": src_lang,
-        "tgt_lang": tgt_lang
-    }
-    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)
-    return resp.json()
-
-class Translate:
-    @staticmethod
-    def run_translate(sentences, src_lang, tgt_lang, **kwargs):
-        from . import _get_client
-        return _get_client().translate(sentences, src_lang, tgt_lang, **kwargs)
-        

dwani-0.1.6/dwani/vision.py

@@ -1,31 +0,0 @@
-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)