BhashaFusion[PhoneticMap]

SELECT * FROM IndianAlphabet 
    WHERE Devanagari == 'ध' 
        OR Bengali–Assamese == 'ध' OR Gujarati == 'ध' 
        OR Kannada == 'ध' OR Malayalam == 'ध' 
        OR Odia == 'ध' OR Tamil == 'ध' 
        OR Telugu == 'ध';

print(phoneticmap.alphabet) # IndianAlphabet
print(phoneticmap.barakhadi)  # Barakhadi
query = PhoneticMap.get_iast_idx_query('ध',phoneticmap.alphabet) # 
print(query.replace('\n','').replace("  ","").replace('OR',' OR')) 
# print()
phoneticmap.get_query(query)
# [{'IAST': 'dha', 'Devanagari': 'ध', 'Bengali–Assamese': 'ধ', 'Gujarati': 'ધ', 'Gurmukhi': 'ਧ', 'Kannada': 'ಧ', 'Malayalam': 'ധ', 'Nastaliq': 'دھ', 'Odia': 'ଧ', 'Sinhala': 'ධ', 'Tamil': None, 'Telugu': 'ధ'}]

print(phoneticmap.get_halant_list()) #>>  ['्', '্', '્', '್', '്', '୍', '్']
print(phoneticmap.('ధృత్రాష్ట్ర ఉవాచ'))

# def to_iast(self,word): 
to_iast = ''
for letter in word: # word
    query = PhoneticMap.get_iast_idx_query(letter,self.alphabet)    
    alpha_token =self.get_query(query)

    query = PhoneticMap.get_iast_idx_query(letter,self.barakhadi)    
    barakhadi_token =self.get_query(query)

    if len(alpha_token) !=0:
        to_iast += alpha_token[0]['IAST']
    elif letter in  self.halant_list and to_iast[-1] in "a":  # >> 'क्' => 'क ' +'्'   # >>> ka + halant = k
        to_iast = to_iast[:-1]
    elif len(barakhadi_token) !=0 and to_iast[-1] in "a":     # >> 'कि' => 'क ' + 'ि' = ka + i => ki
        to_iast = to_iast[:-1]+ barakhadi_token[0]['IAST']
    elif len(barakhadi_token) !=0 :                           # >> ' किं ' =>'क ' + 'ि' + 'ं'  = ka + i + aṁ = kiṁ
        to_iast += barakhadi_token[0]['IAST'].replace("a",'')
    elif len(barakhadi_token) ==0  and len(alpha_token) ==0 and ord(letter)==8205: # cleaing data
        pass
    else:
        # print(f"""NOT Present in alpha and barakadi{letter}=={ord(letter)} """)
        to_iast += letter

text = '''ଧୃତରାଷ୍ଟ୍ର ଉଵାଚ |\tধৃতরাষ্ট্র উবাচ |\tધૃતરાષ્ટ્ર ઉવાચ |\tத்றுதராஷ்ட்ர உவாச |'''
print(phoneticmap.to_iast(text))

text = 'த்றுதராஷ்ட்ர உவாச'
print(phoneticmap.to_iast(text))
phoneticmap.debug_letterbyletter(text)
# chr(805)

# for line in text_telugu.strip().split('\n'):
# source : https://hinduliterature.org/tamil/scriptures/srimad_bhagawad_gita_chapter_1.php
file_name ='bg-hinid'
with open (file_name,'r') as f:
   f_hindi = f.read()  

file_name ='bg-kannada'
with open (file_name,'r') as f:
   f_kanada = f.read()  

file_name ='bg-malayalam'
with open (file_name,'r') as f:
   f_malayalam = f.read()  

file_name ='bg-telugu'
with open (file_name,'r') as f:
   f_telugu = f.read()  

file_name ='bg-oriya'
with open (file_name,'r') as f:
   f_oriya = f.read()  

file_name ='bg-bengali'
with open (file_name,'r') as f:
   f_bengali = f.read()  

file_name ='bg-gujarati'
with open (file_name,'r') as f:
   f_gujarati = f.read()  

file_name ='bg-tamil'
with open (file_name,'r') as f:
   f_tamil = f.read()  

print(len( f_telugu.split('\n')),len(f_kanada.split('\n')), len(f_malayalam.split('\n')), len(f_hindi.split('\n')  ))

min_len  = min(len( f_telugu.split('\n')),len(f_kanada.split('\n')), len(f_malayalam.split('\n')), len(f_hindi.split('\n')  ))
print(f"""LANGUAGE\t| Origian Language Script \t| IAST CONVERT Script """)
for line_idx in range(min_len-1):
    print(line_idx)
    print("-"*40)
    line = f_telugu.strip().split('\n')[line_idx]
    if len(line):
        print(f"""TEL\t| {line.strip()}\t| {phoneticmap.to_iast( line)} """)
    line = f_kanada.strip().split('\n')[line_idx]
    if len(line):
        print(f"""KAN\t| {line.strip()}\t| {phoneticmap.to_iast( line)} """)
    line = f_malayalam.strip().split('\n')[line_idx]
    if len(line):
        print(f"""MAL\t| {line.strip()}\t| {phoneticmap.to_iast( line)} """)
    line = f_hindi.strip().split('\n')[line_idx]
    if len(line):
        print(f"""HIN\t| {line.strip()}\t| {phoneticmap.to_iast( line)} """)
        # print(f""" {phoneticmap.to_iast( line)} """)
    line = f_oriya.strip().split('\n')[line_idx]
    if len(line):
        print(f"""ORI\t| {line.strip()}\t| {phoneticmap.to_iast( line)} """)

    line = f_bengali.strip().split('\n')[line_idx]
    if len(line):
        print(f"""BEN\t| {line.strip()}\t| {phoneticmap.to_iast( line)} """)

    line = f_gujarati.strip().split('\n')[line_idx]
    if len(line):
        print(f"""GUJ\t| {line.strip()}\t| {phoneticmap.to_iast( line)} """)

    line = f_tamil.strip().split('\n')[line_idx]
    if len(line):
        print(f"""TAM\t| {line.strip()}\t| {phoneticmap.to_iast( line)} """)

f_tamil = """ആലായാല്‍ തറ വേണം  അടുത്തൊരമ്പലം വേണം
ആലിനു ചേര്‍ന്നൊരു കുളവും വേണം
കുളിപ്പാനായ് കുളം വേണം  കുളത്തില്‍ ചെന്താമര വേണം
കുളിച്ച് ചെന്നകം പുക്കാന്‍ ചന്ദനം വേണം

പൂവായാല്‍ മണം വേണം  പൂമാനായാല്‍ ഗുണം വേണം
പൂമാനിനിമാര്‍കള്‍ അടക്കം വേണം

യുദ്ധത്തിങ്കല്‍ രാമന്‍ നല്ലൂ, കുലത്തിങ്കല്‍ സീത നല്ലൂ
ഊണുറക്കമുപേക്ഷിക്കാന്‍ ലക്ഷ്മണന്‍ നല്ലൂ
പടയ്ക്ക് ഭരതന്‍ നല്ലൂ, പറവാന്‍ പൈങ്കിളി നല്ലൂ
പറക്കുന്ന പക്ഷികളില്‍ ഗരുഢന്‍ നല്ലൂ

നാടായാല്‍ നൃപന്‍ വേണം  അരികില്‍ മന്ത്രിമാര്‍ വേണം
നാടിനു ഗൂണമുള്ള പ്രജകള്‍ വേണം..

മങ്ങാട്ടച്ചനു ന്യായം നല്ലൂ മംഗല്യത്തിനു സ്വര്‍ണ്ണേ നല്ലൂ
മങ്ങാതിരിപ്പാന്‍ നിലവിളക്ക് നല്ലൂ.

പാല്യത്തച്ചനുപായം നല്ലൂ പാലില്‍ പഞ്ചസാര നല്ലൂ
പാരാതിരിപ്പാന്‍ ചില പദവി നല്ലൂ
"""
# f_tamil = text
lines = f_tamil.strip().split('\n')
for line in lines:
    if len(line):
        print(f"""{phoneticmap.to_iast( line)} """)
        # print(f"""MAL \t {line.strip()}\t {phoneticmap.to_iast( line)} """)

vowel_plist=[['r̥̄', 'l̥̄'],  # len of iast char is 3
             ['r̥', 'au', 'ai', 'ụ̄ ', 'ạ̄ ', 'oṁ', 'm̐', 'aḥ', 'l̥'],  # len of iast char is 2
             ['a', 'ā', 'ạ', 'ụ', 'æ', 'ǣ', 'i', 'ī', 'u', 'ū', 'e', 'ē', 'ê', 'ê',
              'o', 'ǒ', 'ō', 'ô', 'ʻ', 'ḥ', 'ḫ', 'ẖ', 'ṁ', 'ṃ']     # len of iast char is 1
            ]

consonant_list = [['n̆g', 'n̆j', 'n̆ḍ', 'n̆d', 'm̆b', 'k͟h'], # len of iast char is 3
                   ['kh', 'g̈', 'gh', 'ch', 'ĉh', 'jh', 'ṭh', 'ḍh', 'dh', 'd̤', 
                    'ṛh', 'th', 'ph', 'bh', 'b̤', 'ṟ̄', 'y̌', 'r̆', 'l̤', '||'], # len of iast char is 2
                   ['ḵ', 'k', 'g', 'ṅ', 'c', 'ĉ', 'j', 'ǰ', 'ĵ', 'ñ', 'ṭ', 'ḍ', 'ḍ', 
                    'ṛ', 'ṇ', 't', 'd', 'n', 'p', 'b', 'm', 'ṟ', 'ṯ', 'ḏ', 'ṉ',
                    'ḻ', 'y', 'ẏ', 'r', 'l', 'ḷ', 'v', 'ś', 'ṣ', 's', 'h', 'q', 'ġ', 
                    'z', 'z', 'ž', 'ž', 'ž', 'f', 's̱', 's̤', 'h̤', 't̤', 'w',
                    'ẕ', 'ż', 'ẓ', 'ẏ', 'ṟ', 
                    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '|']  # len of iast char is 1
                  ]

# def iast2tokens(word):
vowel_plist=PhoneticMap.vowel_plist
consonant_list=PhoneticMap.consonant_list

iast_tokens= []
vowel_tokens = PhoneticMap.lex_iast(vowel_plist,word)
# print(vowel_tokens)
if word[-1*len(vowel_tokens[-1]):]==vowel_tokens[-1]:
    pass
    # print('Last word match with vowel no need to append')
else:
    vowel_tokens.append(word.split(vowel_tokens[-1])[-1])
    # print('need to append')
    # print(vowel_tokens)
for i in vowel_tokens:
    # print(i, lex_iast(consonant_list,i))
    if len(PhoneticMap.lex_iast(consonant_list,i)) <=1:
        iast_tokens.append(i)
    else:
        iast_tokens.extend(PhoneticMap.lex_iast(consonant_list,i))                  
iast_tokens

# def tokens2dict_tokenes(self,tokens,indic_lang):
input_tokens=''
output_string = []
for token in tokens:
    query_bara = f"""SELECT IAST,{indic_lang} FROM {self.barakhadi} WHERE IAST LIKE '%{token}'"""
    query_alpha = f"""SELECT type, IAST,{indic_lang} FROM {self.alphabet} WHERE IAST LIKE '{token}%'"""
    data_alpha = self.get_query(query_alpha)
    data_bara = self.get_query(query_bara)
    input_tokens += token+ ' '
    temp_dic = dict()
    temp_dic['IAST']=token
    temp_dic['lang']=indic_lang
    if len(data_alpha):
        temp_dic['type']=data_alpha[0]['type']
        # temp_dic['alph']=data_alpha[0][indic_lang] # wrong method if token = n ,n̆ḍa, n̆ja then : 
        # we 1st search result is none which we need to filter
        for entry in data_alpha:
            if token =='r':
                # print(entry)
                if entry['IAST']=='ra':
                    temp_dic['alph']=entry[indic_lang]
                    temp_dic['type']=entry['type']
                    # print(temp_dic)                    
                    break        

            if token =='l':
                if entry['IAST']=='la':
                    temp_dic['alph']=entry[indic_lang]
                    temp_dic['type']=entry['type']
                    # print(temp_dic)                    
                    break        

            if entry[indic_lang] is not None and( token!='r') and ( token!='l') :
                # print(entry['Telugu'],entry['IAST'],entry['type'])
                temp_dic['alph']=entry[indic_lang]
                temp_dic['type']=entry['type']
                break        
        # output_string +=' | '+ data_alpha[0][indic_lang]+' : '  +data_alpha[0]['type'] +' | '
    else:
        temp_dic['alph']=None
    if len(data_bara):
        # output_string +=' | '+ data_bara[0][indic_lang] +' | '
        temp_dic['type']='vowel'
        temp_dic['bara']=data_bara[0][indic_lang]
    else:
        temp_dic['bara']=None
    output_string.append(temp_dic)
return output_string

indic_lang = 'Telugu' # 'Kannada' # 'Telugu'
# tokens = PhoneticMap.iast2tokens(vowel_plist, consonant_list, word) 
tokens = PhoneticMap.iast2tokens( word) 
# print(tokens)
output_string = phoneticmap.tokens2dict_tokenes(tokens,indic_lang)
# print(output_string)
for i in output_string:
    print(i)
# output_string

if current char is `vowel`:
    if previous char is `consonants`:
        if current char =='a':
            skip # 'k','a' => क' + '' >> क'
        else:
            output=output + char['barakadi'] # # 'k','i'= > क' + 'ि' >> कि
    if previous char is `vowel`:
        output=output + char['barakadi'] # # 'k','i','ṁ'= > क' + 'ि' + 'ं' >> किं 
    if previous char is `None`:
        output=output + char['alphabet']       # iti >>इति

if current char is `consonants`:
    if next char is `vowel`:
        output=output + char['alphabet'] # # 'k','i'= > क' + 'ि' >> कि
    if next char is `consonant`:
        output=output + char['alphabet']+ halant # kṣētraṁ: kṣē> k+ṣē >>  क् +षे  >> क्षेत्रं 
    if next char is `None`:
    output=output char['alphabet']+ halant       # tat >>तत्

[{'IAST': 'k', 'lang': 'Telugu', 'type': 'consonants', 'alph': 'క', 'bara': None}
{'IAST': 'a', 'lang': 'Telugu', 'type': 'vowel', 'alph': 'అ', 'bara': None}
{'IAST': 'ṁ', 'lang': 'Telugu', 'alph': None, 'type': 'vowel', 'bara': 'ం'}
{'IAST': '  ', 'lang': 'Telugu', 'alph': None, 'bara': None}
{'IAST': 'i', 'lang': 'Telugu', 'type': 'vowel', 'alph': 'ఇ', 'bara': 'ి'}
{'IAST': 't', 'lang': 'Telugu', 'type': 'consonants', 'alph': 'త', 'bara': None}
{'IAST': 'ā', 'lang': 'Telugu', 'type': 'vowel', 'alph': 'ఆ', 'bara': 'ా'}
{'IAST': 'ḥ', 'lang': 'Telugu', 'alph': None, 'type': 'vowel', 'bara': 'ః'}]

# def dict_tokens2indic(output_string,halant):                    
output=''
for idx, item in enumerate(output_string):
    print_status = False    
    # print(idx, item)
    if idx ==0:
        prev_item=dict()
    else:
        prev_item=output_string[idx-1]
    if idx < len(output_string)-1:

        next_item = output_string[idx+1]
    elif idx ==len(output_string)-1:
        next_item = dict()

    if 'type' in item.keys() and item['type']=='consonants':
        if 'type' in next_item.keys() and next_item['type']=='vowel':
            # print(item['alph'], end=" ")
            output +=item['alph']
            print_status =True
        elif 'type' in next_item.keys() and next_item['type']=='consonants':
            # print(item['alph']+halant,end="")
            output +=item['alph']+halant
            print_status =True
        elif 'type' not in next_item: # word ending with consonant and halant
            output +=item['alph']+halant
            print_status =True


    if 'type' in item.keys() and item['type']=='vowel':
        # print('ITEM: ',item)
        # print('PREV ITEM: ',prev_item)
        if 'type' in prev_item.keys() and prev_item['type']=='consonants':
            # print(item['bara'], end=' ')
            if item['IAST']=='a':
                print_status =True                            
                pass
            else:        
                output +=item['bara']
                print_status =True            
            # print(item)

        if 'type' in prev_item.keys() and prev_item['type']=='vowel':
            output +=item['bara']            
            # print(item)
            print_status =True
        # pass
        if 'type' not in prev_item : # starting of word or starting of line
            if item['alph'] is not None :
                output +=item['alph']                            
                print_status =True                


    if not print_status:
        output +=item['IAST']
    # print(output)
return output

word = 'kaṁ  itāḥ kiṁ  yuyutsavaḥ  pāṇḍavānīkaṁ itāḥ kiṁ āṁ  īṁ  kiṁ yuyutsuṁ rānsakhīṁstathā'
indic_lang = 'Telugu' # 'Kannada' # 'Telugu'
# def iast2indic(iast,vowel_plist,consonant_list,word,indic_lang):
tokens= PhoneticMap.iast2tokens( word)

dict_tokene_list = phoneticmap.tokens2dict_tokenes(tokens,indic_lang)
# print(output_string)
halant=phoneticmap.get_indic_halant(indic_lang)

output=PhoneticMap.dict_tokens2indic(dict_tokene_list,halant)
print(word)
print(tokens)
# print(halant)
print(output)

text = """ālāyāl taṟa vēṇaṁ aṭuttorampalaṁ vēṇaṁ
ālinu cērnnoru kuḷavuṁ vēṇaṁ 
kuḷippānāy kuḷaṁ vēṇaṁ  kuḷattil centāmara vēṇaṁ 
kuḷicc cennakaṁ pukkān candanaṁ vēṇaṁ 
pūvāyāl maṇaṁ vēṇaṁ  pūmānāyāl guṇaṁ vēṇaṁ 
pūmāninimārkaḷ aṭakkaṁ vēṇaṁ 
yuddhattiṅkal rāman nallū, kulattiṅkal sīta nallū 
ūṇuṟakkamupēkṣikkān lakṣmaṇan nallū 
paṭaykk bharatan nallū, paṟavān paiṅkiḷi nallū 
paṟakkunna pakṣikaḷil garuḍhan nallū 
nāṭāyāl nr̥pan vēṇaṁ  arikil mantrimār vēṇaṁ 
nāṭinu gūṇamuḷḷa prajakaḷ vēṇaṁ.. 
maṅṅāṭṭaccanu nyāyaṁ nallū maṁgalyattinu svarṇṇē nallū 
maṅṅātirippān nilaviḷakk nallū. 
pālyattaccanupāyaṁ nallū pālil pañcasāra nallū 
pārātirippān cila padavi nallū 
"""
# working code 
# indic_lang='Devanagari'
# indic_lang='Kannada'
indic_lang='Telugu'

# code is not working for below languages
# indic_lang='Odia'
# indic_lang='Tamil'
# indic_lang='Bengali–Assamese'
for line in text.split('\n'):
    print()
    # print('\n',line)
    # print(line.split(" "))
    for word in line.split(" "):
        # print('\nword:',word, 'len of word:',len(word))
        # output =phoneticmap.iast2indic(vowel_plist,consonant_list,word,indic_lang)
        output =phoneticmap.iast2indic(word,indic_lang)
#         # print(l)
        print(output, end=' ')

# output for indic lang {'Devanagari', 'Kannada', 'Telugu'}

import pandas as pd 
# pd.read_sql_table(phoneticmap.alphabet, phoneticmap.db_connect)
alphabets= pd.read_sql_query(f"SELECT * FROM {phoneticmap.alphabet}", phoneticmap.db_connect)
barakhadi = pd.read_sql_query(f"SELECT * FROM {phoneticmap.barakhadi}", phoneticmap.db_connect)

with pd.ExcelWriter('IASTv2.xlsx', mode="w",engine="openpyxl")as writer:
    alphabets.to_excel(writer, sheet_name=phoneticmap.alphabet,index=False)
    barakhadi.to_excel(writer,sheet_name=phoneticmap.barakhadi,index=False)

import pandas as pd
import sqlite3
path = 'IAST-modified.xlsx'
alphabets = pd.read_excel(path,sheet_name='IndianAlphabet')
barakhadi = pd.read_excel(path,sheet_name='Barakhadi')
# Create new database if not exist and replace old talbe
connect = sqlite3.connect('iast-generated.db')
alphabets.to_sql('IndianAlphabet', connect, if_exists='replace',index=False)
barakhadi.to_sql('Barakhadi', connect, if_exists='replace',index=False)