Created
November 24, 2020 16:07
-
-
Save balachandrana/f352baef949894dd069b4a9dc91585e8 to your computer and use it in GitHub Desktop.
analyze tamil poem
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
# -*- coding: utf-8 -*- | |
from collections import defaultdict | |
import re | |
class AsaiMaps(): | |
def __init__(self): | |
self.map_ner_nirai = {'NER':'e', 'NIRAI':'i', 'OTHERS':'o'} | |
self.map_asai = {'e': 'naal', | |
'i': 'malar', | |
'ee': 'thema', | |
'ie': 'pulima', | |
'ei': 'kuvilam', | |
'ii': 'karuvilam', | |
'eee': 'themankai', | |
'iee': 'pulimankai', | |
'eie': 'kuvilankai', | |
'iie': 'karuvilankai', | |
'eei': 'themankani', | |
'iei': 'pulimankani', | |
'eii': 'kuvilankani', | |
'iii': 'karuvilankani', | |
'eeee': 'themanthanpoo', | |
'ieee': 'pulimanthanpoo', | |
'eiee': 'kuvilanthanpoo', | |
'iiee': 'karuvilanthanpoo', | |
'eeie': 'themanarumpoo', | |
'ieie': 'pulimanarumpoo', | |
'eiie': 'kuvilanarumpoo', | |
'iiie': 'karuvilanarumpoo', | |
'eeei': 'themanthannizhal', | |
'ieei': 'pulimanthannizhal', | |
'eiei': 'kuvilanthannizhal', | |
'iiei': 'karuvilanthannizhal', | |
'eeii': 'themanarunizhal', | |
'ieii': 'pulimanarunizhal', | |
'eiii': 'kuvilanarunizhal', | |
'iiii': 'karuvilanarunizhal' | |
} | |
self.map_reverse_asai = {v:k for k,v in self.map_asai.items()} | |
self.map_reverse_asai['kasu'] = 'ee' | |
self.map_reverse_asai['pirappu'] = 'ie' | |
self.map_thalai = {'thema' :[ | |
'malar', 'pirappu', 'pulima', 'karuvilam', 'pulimankai', 'karuvilankai'], | |
'pulima' :['malar', 'pirappu', 'pulima', 'karuvilam', 'pulimankai', 'karuvilankai'], | |
'kuvilam' :['naal', 'kaasu', 'thema', 'kuvilam', 'themankai', 'kuvilankai'], | |
'karuvilam' :['naal', 'kaasu', 'thema', 'kuvilam', 'themankai', 'kuvilankai'], | |
'themankai' :['naal', 'kaasu', 'thema', 'kuvilam', 'themankai', 'kuvilankai'], | |
'pulimankai' :['naal', 'kaasu', 'thema', 'kuvilam', 'themankai', 'kuvilankai'], | |
'kuvilankai' :['naal', 'kaasu', 'thema', 'kuvilam', 'themankai', 'kuvilankai'], | |
'karuvilankai' :['naal', 'kaasu', 'thema', 'kuvilam', 'themankai', 'kuvilankai']} | |
class SimpleLexer(): | |
def __init__(self, token_in, map=None): | |
self.token_in = token_in | |
self.map = map if map else {} | |
self.init_dict() | |
def init_dict(self): | |
self.string_lendict = defaultdict(list) | |
for t in self.token_in: | |
self.string_lendict[len(t)].append(t) | |
self.maxlen = max(i for i in self.string_lendict.keys()) | |
self.current = 0 | |
def map_out(self, ch): | |
return self.map.get(ch, ch) | |
def get_next_string(self, nextstr, maxlen, lendict): | |
for i in range(maxlen, 0, -1): | |
s = nextstr[:i] | |
if i in lendict: | |
if s in lendict[i]: | |
return s | |
return nextstr[0] | |
def parse_text(self, data): | |
maxlen = self.maxlen | |
current = 0 | |
tokenlist = [] | |
lendict = self.string_lendict | |
while current < len(data): | |
nextstr = data[current:current+maxlen] | |
s = self.get_next_string(nextstr, maxlen, lendict) | |
tokenlist.append(self.map_out(s)) | |
current += len(s) | |
return tokenlist | |
class TamilUnicodeParser(SimpleLexer): | |
def __init__(self): | |
self.ayutham = ['ஃ'] | |
self.uyir = 'அ ஆ இ ஈ உ ஊ எ ஏ ஐ ஒ ஓ ஔ'.split() | |
self.uyir_kuril_nedil = 'k n k n k n k n n k n n'.split() | |
self.mei = [i + 'க்'[1] for i in ''' | |
க ங ச ஞ ட ண த ந ப ம ய ர ல வ ழ ள ற ன ஜ ஶ ஸ ஷ ஹ க்ஷ | |
'''.split()] | |
self.compound_vowels = [i[1:] if len(i) >= 2 else '' for i in ( | |
'க கா கி கீ கு கூ கெ கே கை கொ கோ கௌ').split()] | |
self.uyirmei = [i[:-1]+j for i in self.mei for j in self.compound_vowels] | |
self.uyirmei_kuril_nedil = [ self.uyir_kuril_nedil[ | |
j] for i in self.mei for j, item in enumerate(self.compound_vowels)] | |
self.special_symbols = 'ஶ்ரீ ௐ'.split() | |
self.all_symbols_map = {'ayutham': self.ayutham, 'uyir':self.uyir, 'mei':self.mei, | |
'uyirmei':self.uyirmei, 'special':self.special_symbols} | |
self.all_symbols = self.ayutham+self.uyir+self.mei+self.uyirmei+self.special_symbols | |
self.all_symbols_kuril_nedil_otru = ['o'] + self.uyir_kuril_nedil + [ | |
'o']*len(self.mei)+self.uyirmei_kuril_nedil+['s']*len(self.special_symbols) | |
self.all_symbols_type_map = {v:k for k in self.all_symbols_map for v in self.all_symbols_map[k] } | |
self.all_symbols_index_map = {item:i for i, item in enumerate(self.all_symbols)} | |
self.token_in = self.all_symbols | |
self.map = self.all_symbols_index_map | |
self.init_dict() | |
def endswith_u(self, s): | |
s0 = self.all_symbols_index_map.get(s, s) | |
s1 = s0 - (1+len(self.uyir)+len(self.mei)) | |
return s1%len(self.compound_vowels) == 4 | |
def get_type(self, s): | |
s0 = self.all_symbols[s] if type(s) == type(1) else s | |
return self.all_symbols_type_map.get(s0, 'others') | |
def get_mei_inam(self, s): | |
typ = 'v m v m v m v m v m i i i i i i v m o o o o o o '.split() | |
s0 = self.all_symbols[s] if type(s) == type(1) else s | |
t = self.all_symbols_type_map.get(s0, 'others') | |
if t == 'mei' or t == 'uyirmei': | |
s1 = self.all_symbols_index_map.get(s, s) | |
s2 = s1 - (1+len(self.uyir)) | |
s3 = s2 // len(self.compound_vowels) | |
return typ[s3] | |
else: | |
return 'o' | |
def ezhuthu_type(self, ch): | |
ty = self.get_type(ch) | |
nedil_kuril = self.all_symbols_kuril_nedil_otru[ch] | |
inam = self.get_mei_inam(ch) | |
return (ty, nedil_kuril, inam) | |
def get_char(self, i): | |
if i < 0: | |
return chr(-i) | |
else: | |
return self.all_symbols[i] | |
def print_text(self, tamil_num_text): | |
return ''.join([self.get_char(i) for i in tamil_num_text]) | |
class NerNiraiParser(SimpleLexer): | |
def __init__(self): | |
self.ner = 'koo noo ko no k n o'.split() | |
self.nirai = 'kkoo knoo kko kno kk kn'.split() | |
self.ner_nirai_map = {'NER':self.ner, 'NIRAI':self.nirai} | |
self.ner_nirai_symbols = self.ner + self.nirai | |
self.ner_nirai_symbols_type = { | |
v:k for k in self.ner_nirai_map for v in self.ner_nirai_map[k]} | |
self.ner_nirai_index_map = { | |
item:i for i, item in enumerate(self.ner_nirai_symbols)} | |
self.token_in = self.ner_nirai_symbols | |
self.map = self.ner_nirai_index_map | |
self.init_dict() | |
class SeerParse(): | |
def __init__(self, data): | |
self.asai_maps = AsaiMaps() | |
self.map_ner_nirai = self.asai_maps.map_ner_nirai | |
self.thalai_map = self.asai_maps.map_thalai | |
self.asai_map = self.asai_maps.map_asai | |
self.map_reverse_asai = self.asai_maps.map_reverse_asai | |
self.tamil_unicode_parser = TamilUnicodeParser() | |
self.ner_nirai_parser = NerNiraiParser() | |
self.adi_seer_process(data) | |
def check_thalai(self, nindra, vanda): | |
return vanda in self.thalai_map.get(nindra, []) | |
def get_parsed_text(self, parsed_text, tamil_num_text): | |
t = [] | |
p = 0 | |
for i in parsed_text: | |
l = len(i) | |
t.append(''.join([self.tamil_unicode_parser.all_symbols[j] for j in tamil_num_text[p:p+l]])) | |
p += l | |
return '|'.join([k for k in t]) | |
def parse_text(self, tamil_text): | |
tamil_num_text = [i for i in self.tamil_unicode_parser.parse_text(tamil_text)] | |
kno_text = ''.join([self.tamil_unicode_parser.all_symbols_kuril_nedil_otru[ | |
i] for i in tamil_num_text]) | |
ner_nirai_parsed_text = [t for t in self.ner_nirai_parser.parse_text(kno_text)] | |
parsed_text = [self.ner_nirai_parser.ner_nirai_symbols[t] for t in ner_nirai_parsed_text] | |
parsed_tamil_text = self.get_parsed_text(parsed_text, tamil_num_text) | |
ner_nirai_mapped_text = '|'.join([self.ner_nirai_parser.ner_nirai_symbols_type[ | |
t] for t in parsed_text]) | |
asai = self.asai_map.get(''.join([self.map_ner_nirai[ | |
self.ner_nirai_parser.ner_nirai_symbols_type[t]] for t in parsed_text]), 'OTHERS') | |
return (tamil_num_text, parsed_tamil_text, ner_nirai_mapped_text, asai) | |
def check_venba_eetru_asai(self): | |
last_adi = len(self.adi_seer)-1 | |
last_seer = len(self.adi_seer[last_adi])-1 | |
num_text = self.adi_seer_items[(last_adi, last_seer)][0] | |
asai = self.adi_seer_items[(last_adi, last_seer)][3] | |
self.last_asai = asai | |
if asai == 'naal' or asai == 'malar': | |
result = (asai, True) | |
elif self.tamil_unicode_parser.endswith_u(num_text[-1]): | |
if asai == 'thema': | |
result = ('kaasu', True) | |
elif asai == 'pulima': | |
result = ('pirappu', True) | |
else: | |
result = (asai, False) | |
else: | |
result = (asai, False) | |
self.eetru_asai, self.eetru_seer_result = result | |
u, p, n, a = self.adi_seer_items[(last_adi, last_seer)] | |
self.adi_seer_items[(last_adi, last_seer)] = (u, p, n, self.eetru_asai) | |
def restore_venba_eetru_asai(self): | |
last_adi = len(self.adi_seer)-1 | |
last_seer = len(self.adi_seer[last_adi])-1 | |
asai = self.adi_seer_items[(last_adi, last_seer)][3] | |
if asai =='kaasu' or asai == 'pirappu': | |
u, p, n, a = self.adi_seer_items[(last_adi, last_seer)] | |
self.adi_seer_items[(last_adi, last_seer)] = (u, p, n, self.last_asai) | |
def preprocess(self, data): | |
d = data.replace('-', ' ') | |
while '(' in d: | |
d = re.sub(r'(.*)(\(.*\))(.*)', r'\1\3', d) | |
return d | |
def get_thalai(self, asai1, asai2): | |
rasai1 = self.map_reverse_asai[asai1] | |
rasai2 = self.map_reverse_asai[asai2] | |
if len(rasai1) == 2: | |
if rasai1[-1] == rasai2[0]: | |
if rasai1[-1] == 'e': | |
return 'nerondrasiriyathalai' | |
else: | |
return 'niraiondrasiriyathalai' | |
else: | |
return 'iyarcheervendalai' | |
elif len(rasai1) == 3: | |
if rasai1[-1] == 'e': | |
if rasai2[0] == 'e': | |
return 'venseervendalai' | |
else: | |
return 'kalithalai' | |
else: | |
if rasai1[-1] == 'e': | |
return 'ondriyavanjithalai' | |
else: | |
return 'ondrathavanjithalai' | |
else: | |
return 'others' | |
def count_adi_ezhuthukkal(self): | |
self.adi_ezhuthukkal_count = [0]*len(self.adi_seer) | |
for i, adi in enumerate(self.adi_seer): | |
for j, seer in enumerate(adi): | |
num_text = self.adi_seer_items[(i, j)][0] | |
self.adi_ezhuthukkal_count[i] += sum([ | |
1 for k in num_text if self.tamil_unicode_parser.ezhuthu_type( | |
k)[0] in ['uyir', 'uyirmei'] ]) | |
def adi_seer_process(self, data): | |
self.data = data | |
self.data_preprocessed = self.preprocess(data).strip() | |
self.adi_seer = [i.split() for i in self.data_preprocessed.split('\n')] | |
self.adi_seer_items = {} | |
for i, adi in enumerate(self.adi_seer): | |
for j, seer in enumerate(adi): | |
u, p, n, a = self.parse_text(seer) | |
self.adi_seer_items[(i,j)] = (u, p, n, a) | |
self.adi_seer_thalai = {} | |
for i, adi in enumerate(self.adi_seer): | |
for j, seer in enumerate(adi): | |
if i == len(self.adi_seer)-1 and j == len(adi)-1: | |
self.adi_seer_thalai[(i,j)] = 'last_thalai' | |
else: | |
next_asai = (i, j+1) if j < len(adi)-1 else (i+1, 0) | |
self.adi_seer_thalai[(i,j)] = self.get_thalai(self.adi_seer_items[(i,j)][3], | |
self.adi_seer_items[next_asai][3]) | |
self.count_adi_ezhuthukkal() | |
def adi_seer_text(self): | |
nernirai_split_text_list = [] | |
nernirai_labels_list = [] | |
asai_text_list = [] | |
thalai_check_text_list = [] | |
for i, adi in enumerate(self.adi_seer): | |
nernirai_split_text_list.append(' '.join(self.adi_seer_items[(i,k)][ | |
1] for k in range(len(adi)))) | |
nernirai_labels_list.append(' '.join(self.adi_seer_items[(i,k)][2] for k in range(len(adi)))) | |
asai_text_list.append(' '.join(self.adi_seer_items[(i,k)][3] for k in range(len(adi)) ) ) | |
thalai_check_text_list.append(' '.join(self.adi_seer_thalai[(i,k)] for k in range(len(adi)) )) | |
self.nernirai_split_text = '\n'.join(nernirai_split_text_list) | |
self.nernirai_labels = '\n'.join(nernirai_labels_list) | |
self.asai_text = '\n'.join(asai_text_list) | |
self.thalai_check_text = '\n'.join(thalai_check_text_list) | |
def check_nerisai_venba_edugai(self): | |
first_seer_letters = [] | |
for i, adi in enumerate(self.adi_seer): | |
first_seer_letters.append((self.tamil_unicode_parser.ezhuthu_type(self.adi_seer_items[(i, 0)][0][0])[1], | |
self.adi_seer_items[(i, 0)][0][1] )) | |
if i == 1: | |
first_seer_letters.append((self.tamil_unicode_parser.ezhuthu_type(self.adi_seer_items[(i, 3)][0][0])[1], | |
self.adi_seer_items[(i, 3)][0][1] )) | |
nk, ch = first_seer_letters[0] | |
result = all([nk == i and ch == j for i,j in first_seer_letters[:3]]) | |
nk, ch = first_seer_letters[3] | |
result = result and (nk == first_seer_letters[4][0] and | |
ch == first_seer_letters[4][1]) | |
self.result_venba_edugai = result | |
return result | |
def check_venba_edugai(self): | |
first_seer_letters = [] | |
for i, adi in enumerate(self.adi_seer): | |
first_seer_letters.append((self.tamil_unicode_parser.ezhuthu_type(self.adi_seer_items[(i, 0)][0][0])[1], | |
self.adi_seer_items[(i, 0)][0][1] )) | |
nk, ch = first_seer_letters[0] | |
result = (nk == first_seer_letters[1][0] and | |
ch == first_seer_letters[1][1]) | |
if len(first_seer_letters) == 4: | |
nk, ch = first_seer_letters[2] | |
result = result and (nk == first_seer_letters[3][0] and | |
ch == first_seer_letters[3][1]) | |
self.result_venba_edugai = result | |
return result | |
def check_venba_thalai(self): | |
self.result_venba_edugai = all((i == 'venseervendalai') or (i == 'iyarcheervendalai' | |
) or (i == 'last_thalai') for i in self.adi_seer_thalai.values()) | |
return self.result_venba_edugai | |
def check_venba(self): | |
adi_length = len(self.adi_seer) | |
if adi_length > 1: | |
if all(len(adi)==4 for adi in self.adi_seer[:-1]): | |
if len(self.adi_seer[-1]) == 3: | |
self.check_venba_eetru_asai() | |
self.adi_seer_text() | |
self.restore_venba_eetru_asai() | |
r1 = self.check_venba_thalai() | |
result = self.check_venba_thalai() and self.eetru_seer_result | |
if adi_length == 2: | |
if self.check_venba_edugai(): | |
if result: | |
return 'kural_venba' | |
return 'others' | |
elif adi_length == 3: | |
if result: | |
return 'sindiyal_venba' | |
return 'others' | |
elif adi_length == 4: | |
if self.check_nerisai_venba_edugai(): | |
if result: | |
return 'nerisai_venba' | |
return 'others' | |
if self.check_venba_edugai(): | |
if result: | |
return 'innisai_venba' | |
return 'others' | |
return 'others' | |
elif adi_length < 13: | |
if result: | |
return 'patrodai_venba' | |
return 'others' | |
else: | |
if result: | |
return 'kali_venba' | |
return 'others' | |
return 'others' | |
def check_ekaram_at_the_end(self): | |
last_adi = len(self.adi_seer)-1 | |
last_seer = len(self.adi_seer[-1])-1 | |
last_letter = self.adi_seer_items[(last_adi, last_seer)][0][-1] | |
return (last_letter%16 == 7) | |
def check_asiriyappa(self): | |
self.adi_seer_text() | |
seer_count = len(self.adi_seer_items) | |
adi_length = len(self.adi_seer) | |
eerasai_seer_count = 0 | |
kai_seer_count = 0 | |
other_count = 0 | |
for i, adi in enumerate(self.adi_seer): | |
for j, seer in enumerate(adi): | |
if self.adi_seer_items[(i,j)][3] in ['thema', 'pulima', | |
'kuvilam', 'karuvilam']: | |
eerasai_seer_count += 1 | |
elif self.adi_seer_items[(i,j)][3] in ['themankai', | |
'pulimankai', 'kuvilankai', 'karuvilankai']: | |
kai_seer_count += 1 | |
else: | |
other_count += 1 | |
thalai_count = sum( 1 if (i == 'nerondrasiriyathalai') or (i == 'niraiondrasiriyathalai' | |
) else 0 for i in self.adi_seer_thalai.values()) | |
result = False | |
if other_count == 0: | |
if eerasai_seer_count/seer_count >= .8: | |
if thalai_count/seer_count >= .3: | |
result = True | |
self.asiriyappa_result = (result, seer_count, eerasai_seer_count, thalai_count) | |
if adi_length > 1: | |
self.asiriyappa_ekaram = self.check_ekaram_at_the_end() | |
if result: | |
if all(len(adi)==4 for adi in self.adi_seer): | |
return 'nilaimandilaasiriyappa' | |
elif adi_length > 2 and all( | |
len(adi)==4 for adi in self.adi_seer[:-2]) and ( | |
len(self.adi_seer[-2]) == 3) and (len(self.adi_seer[-1]) == 4) : | |
return 'nerisaiasiriyappa' | |
elif adi_length > 2 and all( | |
len(adi) <= 4 for adi in self.adi_seer[1:-1]) and ( | |
len(self.adi_seer[0]) == 4) and (len(self.adi_seer[-1]) == 4) : | |
return 'inaikuralasiriyappa' | |
else: | |
return 'others' | |
return 'others' | |
def check_alavoththa_seergal(self): | |
first_seer_list = [self.adi_seer_items[(0,i)][3] for i in range(len(self.adi_seer[0]))] | |
result = True | |
for i, adi in enumerate(self.adi_seer): | |
for j, seer in enumerate(adi): | |
if self.adi_seer_items[(i,j)][3] == first_seer_list[j]: | |
continue | |
else: | |
return False | |
return result | |
def check_edugai_kaliviruththam(self): | |
first_seer_letters = [] | |
for i, adi in enumerate(self.adi_seer): | |
first_seer_letters.append((self.tamil_unicode_parser.ezhuthu_type( | |
self.adi_seer_items[(i, 0)][0][0])[1], | |
self.adi_seer_items[(i, 0)][0][1])) | |
nk, ch = first_seer_letters[0] | |
return all([nk == i and ch == j for i,j in first_seer_letters]) | |
def combine_asai_text(self): | |
self.combined_asai_text_letter_count = '\n'.join( | |
[ i+' ' +j for i,j in zip(self.asai_text.strip().split('\n'), | |
[str(i) for i in self.adi_ezhuthukkal_count]) ]) | |
def check_kaliviruththam_kalithogai(self): | |
self.adi_seer_text() | |
self.combine_asai_text() | |
if all(len(adi) == 4 for adi in self.adi_seer): | |
if self.check_edugai_kaliviruththam(): | |
if self.check_alavoththa_seergal(): | |
if len(self.adi_seer) == 4: | |
return 'kaliviruththam' | |
elif len(self.adi_seer) == 5: | |
return 'kalithogai' | |
else: | |
return 'others' | |
return 'others' | |
data1 = ''' | |
சாதி இரண்டொழிய வேறில்லை சாற்றுங்கால் | |
நீதி வழுவா நெறிமுறையின் - மேதினியில் | |
இட்டார் பெரியார் இடாதார் இழிகுலத்தார் | |
பட்டாங்கில் உள்ள படி | |
''' | |
data2 = ''' | |
இன்னுயிர் போயின் திரும்பி வராதெனினும் | |
தன்னுயிர்த் தந்தேனும் காத்திட்டார் - தன்னலம் | |
பாராது யிர்நீத்த பண்பாளர் எந்நாளும் | |
தீராப் புகழ்தான வர்க்கு | |
''' | |
data3 = ''' | |
மன்னனும் மாசறக் கற்றோனும் சீர்தூக்கின் | |
மன்னனில் கற்றோன் சிறப்புடையன் - மன்னர்க்குத் | |
தன்தேசம் அல்லால் சிறப்பில்லை கற்றோற்குச் | |
சென்றஇடம் எல்லாம் சிறப்பு | |
''' | |
data4 = ''' | |
அகர முதல எழுத்தெல்லாம் ஆதி | |
பகவன் முதற்றே உலகு | |
''' | |
data5 = ''' | |
உடுக்கை இழந்தவன் கைபோல ஆங்கே | |
இடுக்கண் களைவதாம் நட்பு | |
''' | |
data6 = ''' | |
அறிந்தானை ஏத்தி அறிவாங் கறிந்து | |
செறிந்தார்க்குச் செவ்வன் உரைப்ப - செறிந்தார் | |
சிறந்தமை ஆராய்ந்து கொண்டு | |
''' | |
data7 = ''' | |
வண்ணத்தைத் தேடி மலியத் தொகுத்துவைத்து | |
கிண்ணத்தி லூற்றிக் கிழியெடுத்துத் தூரிகையை | |
நண்ணவைத்துத் தீட்டும் நயமில்லா ஓவியனே | |
எண்ணமெங்கே வைத்தாய் இசை | |
''' | |
asiriyappa_data1 = ''' | |
சோதனை வந்ததும் சோர்வுக ளுற்று | |
வேதனை கொள்வதை விடுத்திடு தோழா | |
துயரினைப் போக்கிடத் துணிந்திடு | |
பயங்கொள ளென்றும் பைத்தியச் செயலே | |
''' | |
asiriyappa_data2 = ''' | |
நன்னூல் வழங்கிடும் நன்மொழி நம்பு | |
கன்னல் சொல்லும் கனிதரும் தெம்பு | |
கொண்டு மேல்செல் குன்று | |
விண்டு சுவைத்து விருந்தளி பெண்ணே | |
''' | |
asiriyappa_data3 = ''' | |
உன்னை நம்பி யுலகுவெல் தமிழா | |
தன்னை நம்புந் தமிழை | |
அன்னையாய்க் கொண்டாய் அளியென் வேறே | |
''' | |
kaliviruththam_data1 = ''' | |
நன்கவி நற்கவி நாடியோர் முன்பென் | |
புன்கவி புகுமெனப் புகுந்தனன் புலவோர் | |
இன்கவி இயற்றுவர் எளிதினில் இயலா(து) | |
என்கவி இயற்றுவன் எனைப்பொறுத் தருள்க | |
''' | |
kaliviruththam_data2 = ''' | |
வாய்க்க ரும்பது வாய்தவக் கோளது | |
வாய்த்தி கழ்ந்திரு மாமழை மாமலை | |
வாய்க்கொ ழுந்தது மாமணி வாய்த்திரு | |
வாய்ச்சிந் துந்தமிழ் வானெனுஞ் சோல(லை)யே | |
''' | |
kaliviruththam_data3 = ''' | |
நின்றது நெஞ்சினில் நேயம் விட்டெனைச் | |
சென்றது துயர்வழித் தேங்கல் புலவரின் | |
மன்றினில் நிற்குமிம் மாயம் செய்தது | |
கன்றுளங் காட்டிய காவின் இனிமையே | |
''' | |
def write_text(filename, txt): | |
with open(filename, 'w', encoding='utf-8') as fp: | |
fp.write(txt) | |
def print_venba_test(data, filename="out1.txt"): | |
seer_parse = SeerParse( data) | |
result = seer_parse.check_venba() | |
txt = f''' | |
{data} | |
venba grammar {result} | |
edugai {seer_parse.result_venba_edugai} | |
{seer_parse.nernirai_split_text} | |
{seer_parse.nernirai_labels} | |
{seer_parse.asai_text} | |
{seer_parse.thalai_check_text} | |
''' | |
#print(txt) | |
write_text(filename, txt) | |
''' | |
print(f'venba grammar {result}\n') | |
print(f'edugai {seer_parse.result_venba_edugai}') | |
print(f'{seer_parse.nernirai_split_text}\n') | |
print(f'{seer_parse.nernirai_labels} \n') | |
print(f'{seer_parse.asai_text}\n') | |
print(f'{seer_parse.thalai_check_text} \n') | |
''' | |
def print_asiriyappa_test(data): | |
seer_parse = SeerParse(data) | |
result = seer_parse.check_asiriyappa() | |
(result, seer_count, eerasai_seer_count, thalai_count) = seer_parse.asiriyappa_result | |
print(f'asiriyappa grammar {result}\n') | |
print(f'ekaram at the end {seer_parse.asiriyappa_ekaram}') | |
print(f'result = {result} seer_count = {seer_count}') | |
print(f'eerasai_seer_count = {eerasai_seer_count} thalai_count = {thalai_count}') | |
print(f'{seer_parse.nernirai_split_text}\n') | |
print(f'{seer_parse.nernirai_labels} \n') | |
print(f'{seer_parse.asai_text}\n') | |
def print_kaliviruththam_kalithogai_test(data): | |
seer_parse = SeerParse(data) | |
result = seer_parse.check_kaliviruththam_kalithogai() | |
print(f'{result}\n') | |
print(f'{seer_parse.nernirai_split_text}\n') | |
print(f'{seer_parse.nernirai_labels} \n') | |
#print(f'{seer_parse.asai_text}\n') | |
#print(seer_parse.adi_ezhuthukkal_count) | |
print(seer_parse.combined_asai_text_letter_count) | |
if __name__ == '__main__': | |
#print_venba_test(data1, filename="dataou1.txt") | |
print_venba_test(data2, filename="dataou2.txt") | |
#print_venba_test(data3, filename="dataou3.txt") | |
#print_venba_test(data4, filename="dataou4.txt") | |
#print_venba_test(data5, filename="dataou5.txt") | |
#print_venba_test(data6, filename="dataou6.txt") | |
#print_venba_test(data7, filename="dataou7.txt") | |
#print_asiriyappa_test(asiriyappa_data3) | |
#print_kaliviruththam_kalithogai_test(kaliviruththam_data3) | |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment