dwani 0.1.5__py3-none-any.whl → 0.1.7__py3-none-any.whl

dwani/__init__.py

@@ -3,9 +3,11 @@ 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"]
+__all__ = ["DhwaniClient", "Chat", "Audio", "Vision", "ASR", "DhwaniAPIError", "Translate", "Documents"]
 
 # Optionally, instantiate a default client for convenience
 api_key = None
@@ -37,3 +39,27 @@ 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/asr.py

@@ -1,10 +1,44 @@
 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={language}",
+            f"{client.api_base}/v1/transcribe/?language={api_language}",
             headers=client._headers(),
             files=files
         )
@@ -16,5 +50,4 @@ class ASR:
     @staticmethod
     def transcribe(*args, **kwargs):
         from . import _get_client
-        return _get_client().transcribe(*args, **kwargs)
-
+        return _get_client().transcribe(*args, **kwargs)

dwani/chat.py

@@ -1,12 +1,50 @@
 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,
-        "tgt_lang": tgt_lang
+        "src_lang": src_lang_code,
+        "tgt_lang": tgt_lang_code
     }
     payload.update(kwargs)
     resp = requests.post(
@@ -22,4 +60,4 @@ 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)
+        return _get_client().chat(prompt, src_lang, tgt_lang, **kwargs)

dwani/client.py

@@ -12,35 +12,43 @@ class DhwaniClient:
     def _headers(self):
         return {"X-API-Key": self.api_key}
 
-    def chat(self, prompt, src_lang, tgt_lang, **kwargs):
-        from .chat import chat_create
-        return chat_create(self, prompt, src_lang, tgt_lang, **kwargs)
-    
     def translate(self, sentences, src_lang, tgt_lang, **kwargs):
         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, **kwargs)
 
-    def speech(self, *args, **kwargs):
+    def chat(self, prompt, src_lang, tgt_lang, **kwargs):
+        from .chat import chat_create
+        return chat_create(self, prompt=prompt, src_lang=src_lang, tgt_lang=tgt_lang, **kwargs)
+    
+    def speech(self, input, response_format="mp3", **kwargs):
         from .audio import audio_speech
-        return audio_speech(self, *args, **kwargs)
+        return audio_speech(self, input=input, response_format=response_format, **kwargs)
 
-    def caption(self, file_path, query="describe the image", src_lang="eng_Latn", tgt_lang="kan_Knda"):
+    def caption(self, file_path, query="describe the image", src_lang="eng_Latn", tgt_lang="kan_Knda", **kwargs):
         from .vision import vision_caption
-        return vision_caption(self, file_path, query, src_lang, tgt_lang)
+        return vision_caption(self, file_path=file_path, query=query, src_lang=src_lang, tgt_lang=tgt_lang, **kwargs)
 
-    def transcribe(self, *args, **kwargs):
+    def transcribe(self, file_path, language=None, **kwargs):
         from .asr import asr_transcribe
-        return asr_transcribe(self, *args, **kwargs)
+        return asr_transcribe(self, file_path=file_path, language=language, **kwargs)
     
-    def document_ocr(self, file_path, language=None):
+    def document_ocr(self, file_path, language=None, **kwargs):
         from .docs import document_ocr
-        return document_ocr(self, file_path, language)
-
-    def document_translate(self, file_path, src_lang, tgt_lang):
-        from .docs import document_translate
-        return document_translate(self, file_path, src_lang, tgt_lang)
+        return document_ocr(self, file_path=file_path, language=language, **kwargs)
 
-    def document_summarize(self, file_path, language=None):
+    def document_summarize(self, file_path, page_number=1, src_lang="eng_Latn", tgt_lang="kan_Knda", **kwargs):
         from .docs import document_summarize
-        return document_summarize(self, file_path, language)
+        return document_summarize(self, file_path, page_number, src_lang, tgt_lang, **kwargs)
+
+    def extract(self, file_path, page_number=1, src_lang="eng_Latn", tgt_lang="kan_Knda", **kwargs):
+        from .docs import extract
+        return extract(self, file_path=file_path, page_number=page_number, src_lang=src_lang,tgt_lang=tgt_lang, **kwargs)
+
+
+    def doc_query( self, file_path, page_number=1, prompt="list the key points", src_lang="eng_Latn", tgt_lang="kan_Knda" , **kwargs ):
+        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 )
 
+    def doc_query_kannada(self, file_path, page_number=1, prompt="list key points", src_lang="eng_Latn", language=None, **kwargs):
+        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)

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(),
@@ -18,17 +54,24 @@ def document_ocr(client, file_path, language=None):
         raise DhwaniAPIError(resp)
     return resp.json()
 
-def document_translate(client, file_path, src_lang, tgt_lang):
-    """Translate a document (image/PDF with text) from src_lang to tgt_lang."""
+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": f}
+        files = {"file": (file_path, f, "application/pdf")}
         data = {
-            "src_lang": src_lang,
-            "tgt_lang": tgt_lang
+            "page_number": str(page_number),
+            "src_lang": src_lang_code,
+            "tgt_lang": tgt_lang_code
         }
         resp = requests.post(
-            f"{client.api_base}/v1/document/translate",
-            headers=client._headers(),
+            url,
+            headers=headers,
             files=files,
             data=data
         )
@@ -36,16 +79,90 @@ def document_translate(client, file_path, src_lang, tgt_lang):
         raise DhwaniAPIError(resp)
     return resp.json()
 
-def document_summarize(client, file_path, language=None):
-    """Summarize a document (image/PDF/text)."""
+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": f}
-        data = {}
-        if language:
-            data["language"] = language
+        files = {"file": (file_path, f, "application/pdf")}
         resp = requests.post(
-            f"{client.api_base}/v1/document/summarize",
-            headers=client._headers(),
+            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
         )
@@ -60,11 +177,21 @@ class Documents:
         return _get_client().document_ocr(file_path, language)
 
     @staticmethod
-    def translate(file_path, src_lang, tgt_lang):
+    def summarize(*args, **kwargs):
         from . import _get_client
-        return _get_client().document_translate(file_path, src_lang, tgt_lang)
-
+        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 summarize(file_path, language=None):
+    def run_doc_query_kannada(*args, **kwargs):
         from . import _get_client
-        return _get_client().document_summarize(file_path, language)
+        return _get_client().doc_query_kannada(*args, **kwargs)

dwani/translate.py

@@ -1,12 +1,50 @@
 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,
-        "tgt_lang": tgt_lang
+        "src_lang": src_lang_code,
+        "tgt_lang": tgt_lang_code
     }
     payload.update(kwargs)
     resp = requests.post(
@@ -20,10 +58,6 @@ def run_translate(client, sentences, src_lang, tgt_lang, **kwargs):
 
 class Translate:
     @staticmethod
-    def translate(sentence, src_lang, tgt_lang, **kwargs):
+    def run_translate(sentences, src_lang, tgt_lang, **kwargs):
         from . import _get_client
-        client = _get_client()
-        # Ensure sentences is always a list
-        response = run_translate(client, [sentence], src_lang, tgt_lang, **kwargs)
-        # Return the first translation, or None if not found
-        return response.get("translations", [None])[0]
+        return _get_client().translate(sentences, src_lang, tgt_lang, **kwargs)

dwani/vision.py

@@ -1,15 +1,53 @@
 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}&tgt_lang={tgt_lang}"
+        f"?src_lang={src_lang_code}&tgt_lang={tgt_lang_code}"
     )
     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")}
@@ -28,4 +66,4 @@ class Vision:
     @staticmethod
     def caption(*args, **kwargs):
         from . import _get_client
-        return _get_client().caption(*args, **kwargs)
+        return _get_client().caption(*args, **kwargs)

{dwani-0.1.5.dist-info → dwani-0.1.7.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: dwani
-Version: 0.1.5
-Summary: Multimodal API for Indian languages (speech, vision, LLMs, TTS, ASR, etc.)
+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
@@ -59,6 +62,10 @@ dwani.api_base = os.getenv("DWANI_API_BASE_URL")
 resp = dwani.Chat.create(prompt="Hello!", src_lang="eng_Latn", tgt_lang="kan_Knda")
 print(resp)
 ```
+```json
+{'response': 'ನಮಸ್ತೆ! ಭಾರತ ಮತ್ತು ಕರ್ನಾಟಕವನ್ನು ಗಮನದಲ್ಲಿಟ್ಟುಕೊಂಡು ಇಂದು ನಿಮ್ಮ ಪ್ರಶ್ನೆಗಳಿಗೆ ನಾನು ನಿಮಗೆ ಹೇಗೆ ಸಹಾಯ ಮಾಡಲಿ?'}
+```
+
 
 #### Vision Query
 ```python
@@ -70,13 +77,27 @@ result = dwani.Vision.caption(
 )
 print(result)
 ```
+```json
+{'answer': 'ಒಂದು ವಾಕ್ಯದಲ್ಲಿ ಚಿತ್ರದ ಸಾರಾಂಶವನ್ನು ಇಲ್ಲಿ ನೀಡಲಾಗಿದೆಃ ಪ್ರಕಟಣೆಯ ಅವಲೋಕನವು ಪ್ರಸ್ತುತ ಅರವತ್ತನಾಲ್ಕು ದೇಶಗಳು/ಪ್ರದೇಶಗಳನ್ನು ಸೇರಿಸಲಾಗಿದೆ ಮತ್ತು ಇನ್ನೂ ಹದಿನಾರು ಪ್ರದೇಶಗಳನ್ನು ಸೇರಿಸಬೇಕಾಗಿದೆ. ಒದಗಿಸಲಾದ ಚಿತ್ರದಲ್ಲಿ ಲಾಂಛನವು ಕಾಣಿಸುವುದಿಲ್ಲ.'}
+```
 
 #### Speech to Text -  Automatic Speech Recognition (ASR)
 ```python
 result = dwani.ASR.transcribe(file_path="kannada_sample.wav", language="kannada")
 print(result)
 ```
+```json
+{'text': 'ಕರ್ನಾಟಕ ದ ರಾಜಧಾನಿ ಯಾವುದು'}
+```
 
+### Translate
+```python
+resp = dwani.Translate.run_translate(sentences=["hi"], src_lang="eng_Latn", tgt_lang="kan_Knda")
+print(resp)
+```
+```json
+{'translations': ['ಹಾಯ್']}
+```
 #### Text to Speech -  Speech Synthesis
 
 ```python
@@ -85,16 +106,18 @@ with open("output.mp3", "wb") as f:
     f.write(response)
 ```
 
-
+#### Document - Extract Text
+```python
+result = dwani.Documents.run_extract(file_path = "dwani-workshop.pdf", page_number=1, src_lang="eng_Latn",tgt_lang="kan_Knda" )
+print(result)
+```
+```json
+{'pages': [{'processed_page': 1, 'page_content': ' a plain text representation of the document', 'translated_content': 'ಡಾಕ್ಯುಮೆಂಟ್ನ ಸರಳ ಪಠ್ಯ ಪ್ರಾತಿನಿಧ್ಯವನ್ನು ಇಲ್ಲಿ ನೀಡಲಾಗಿದೆ, ಅದನ್ನು ಸ್ವಾಭಾವಿಕವಾಗಿ ಓದುವಂತೆಃ'}]}
+```
 
 - Website -> [dwani.ai](https://dwani.ai)
 
 
-
-#### Contact
-- For any questions or issues, please open an issue on GitHub or contact us via email.
-- For collaborations
-  - Join the discord group - [invite link](https://discord.gg/WZMCerEZ2P) 
 <!-- 
 ## local development
 pip install -e .

dwani-0.1.7.dist-info/RECORD

@@ -0,0 +1,14 @@
+dwani/__init__.py,sha256=ldO5OND7DvJlbxaQ0R57Cc73jJTnCSslDDt4I4r-Op8,1895
+dwani/asr.py,sha256=3LYrLOaMhc5eXKFSoi63C8KAvwZI2NcuO25pwTfSVe0,1692
+dwani/audio.py,sha256=Q9vw4uBxGy1vQzmiZjZGrY8hkAEQNkGhjz5OcnpFEQQ,888
+dwani/chat.py,sha256=dQCl8lLQczwnAsvYlTZowd471ktRVZcW3w8gZ5Wpzms,2097
+dwani/client.py,sha256=OrnwqxBQMfEZ1iQEleFigNujiZve3ox53yv5aSmB3iQ,2849
+dwani/docs.py,sha256=EO41opJwfDFsNmH6nQl-HOsyWravCnj1f5ZDgxSZECI,6323
+dwani/exceptions.py,sha256=qEN5ukqlnN7v-kHNEnISWFMpPMt6uTft9mPsTXJ4LVA,227
+dwani/translate.py,sha256=IJiKrYIfwdJKc_PjlZKVRAwzpQDst_2MF_B_huxid_E,2185
+dwani/vision.py,sha256=wN7WkMRVmLrZnBJxnam7vihTXWGlWJ4JqXgyrp-tbrg,2330
+dwani-0.1.7.dist-info/licenses/LICENSE,sha256=IAD8tbwWZbPWHXgYjabHoMv0aaUzZUYzYiEbfhTCisY,1070
+dwani-0.1.7.dist-info/METADATA,sha256=ggOY4wss1nwN6PzhB0BZG5332emrP6C76qwjaK2mzSs,4810
+dwani-0.1.7.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+dwani-0.1.7.dist-info/top_level.txt,sha256=AM5EhkyuO_EXQFR9JIxEV6tAYMCCyc-a1dLifpCGBUk,6
+dwani-0.1.7.dist-info/RECORD,,

{dwani-0.1.5.dist-info → dwani-0.1.7.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.4.0)
+Generator: setuptools (80.7.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

dwani-0.1.5.dist-info/RECORD

@@ -1,14 +0,0 @@
-dwani/__init__.py,sha256=P2pyHkZ7JHn6lHSEbCdV4hjYAwCOXHN3RbsNIU0F5PE,1084
-dwani/asr.py,sha256=Y5Mbv1KsvhfXNZacMZycUHPn79NRQC-XPH0j9SYPUSY,590
-dwani/audio.py,sha256=Q9vw4uBxGy1vQzmiZjZGrY8hkAEQNkGhjz5OcnpFEQQ,888
-dwani/chat.py,sha256=WFuEShNd4nd6KUbIZTkm3eyPGoP33GepOLJax86nNn8,720
-dwani/client.py,sha256=saQxRBcERSMoCMOqBIe_IqRygh9-e4KxF3iZZvBEZDc,1826
-dwani/docs.py,sha256=2B87KqshPl7-2gDJAJxdvcgmPWuC2IQ1FcsDIyeVJPg,2202
-dwani/exceptions.py,sha256=qEN5ukqlnN7v-kHNEnISWFMpPMt6uTft9mPsTXJ4LVA,227
-dwani/translate.py,sha256=nYB62DLoPf7Weg26aNtpoEpyasDIsArVTzl5xKPp6eI,972
-dwani/vision.py,sha256=JtMSS0hI-8gxtLugVP10__enZsPPy8jheMyWXvrGrdw,1015
-dwani-0.1.5.dist-info/licenses/LICENSE,sha256=IAD8tbwWZbPWHXgYjabHoMv0aaUzZUYzYiEbfhTCisY,1070
-dwani-0.1.5.dist-info/METADATA,sha256=qxXqLp_wZG_eoGD29p1HdVZFjfpG4ExxJ1xDeyb6O7U,3118
-dwani-0.1.5.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
-dwani-0.1.5.dist-info/top_level.txt,sha256=AM5EhkyuO_EXQFR9JIxEV6tAYMCCyc-a1dLifpCGBUk,6
-dwani-0.1.5.dist-info/RECORD,,