tamilstring 0.3.25__py3-none-any.whl

tamilstring/__init__.py

@@ -0,0 +1,3 @@
+from .helper import String, Letter
+
+from .utf8 import get_letters

tamilstring/constant.py

@@ -0,0 +1,18 @@
+VOULES_LET = ["அ","ஆ","இ","ஈ","உ","ஊ","எ","ஏ","ஐ","ஒ","ஓ","ஔ"]
+VOULES_SYM = ["ா", "ி", "ீ", "ு", "ூ", "ெ", "ே", "ை", "ொ", "ோ", "ௌ" ]
+EXACT_VOULE = ["அ","ஆ","இ","ஈ","உ","ஊ","எ","ஏ","ஐ","ஒ","ஓ","ஔ"]
+EXACT_CONSTANT =["க","ங","ச","ஞ","ட","ண","த","ந","ப","ம","ய","ர","ல","வ","ழ","ள","ற","ன"]
+UTF_VOULE = ['்',  "ா", "ி", "ீ", "ு", "ூ", "ெ", "ே", "ை", "ொ", "ோ", "ௌ" ]
+AUTHAM = "ஃ"
+sanskrit_letters = ["ஶ", "ஜ", "ஷ", "ஸ", "ஹ", "க்ஷ"]
+sanskrit_mei_letters = ["ஶ்", "ஜ்", "ஷ்", "ஸ்", "ஹ்", "க்ஷ்"]
+tamil_num = ["௦", "௧", "௨", "௩", "௪", "௫", "௬", "௭", "௮", "௯", "௰""௱","௲"]
+tamil_sym=["௳","௴","௵","௶","௷","௹","௺"]
+english_alp_sm = ["a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]
+english_alp_cp = ["A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z"]
+english_num = ["0","1","2","3","4","5","6","7","8","9"]
+english_sym = [".",",","?",":",";"]
+
+HARD_CONSTAND = ["க்","ச்","ட்","த்","ப்","ற்"]
+SOFT_CONSTANT = ["ங்","ஞ்","ண்","ந்", "ம்","ன்"]
+ 

tamilstring/func.py

@@ -0,0 +1,227 @@
+from .helper import String, Letter
+from .constant import SOFT_CONSTANT,HARD_CONSTAND
+
+letter_singleton_source = Letter(singleton = True)
+letter_singleton_backup = letter_singleton_source.letter
+
+string_singleton_source = String(singleton = True)
+string_singleton_backup = string_singleton_source.string    
+
+def is_english(vowel):
+    take_letter_backup(vowel)
+    return_bool = True if letter_singleton_source.lang == "en" else False
+    restore_letter_backup()
+    return return_bool
+
+def is_tamil(vowel):
+    take_letter_backup(vowel)
+    return_bool = True if letter_singleton_source.lang == "ta" else False
+    restore_letter_backup()
+    return return_bool
+
+def is_sanskrit(vowel):
+    take_letter_backup(vowel)
+    return_bool = True if letter_singleton_source.lang == "sa" else False
+    restore_letter_backup()
+    return return_bool
+
+def is_tamil_num(vowel):
+    take_letter_backup(vowel)
+    return_bool = True if letter_singleton_source.lang == "ta" and letter_singleton_source.kind == "NUM" else False
+    restore_letter_backup()
+    return return_bool
+
+def is_english_num(vowel):
+    take_letter_backup(vowel)    
+    return_bool = True if letter_singleton_source.lang == "en" and letter_singleton_source.kind == "NUM" else False
+    restore_letter_backup()
+    return return_bool
+
+def is_tamil_char(vowel):
+    take_letter_backup(vowel)
+    return_bool = True if letter_singleton_source.kind == "CAR" else False
+    restore_letter_backup()
+    return return_bool
+
+def is_vowel(vowel):
+    take_letter_backup(vowel)
+    return_bool = True if letter_singleton_source.is_voule else False
+    restore_letter_backup()
+    return return_bool
+
+def is_constant(constant):
+    take_letter_backup(constant)
+    return_bool = True if letter_singleton_source.is_constant else False
+    restore_letter_backup()
+    return return_bool
+
+def is_compound(compound):
+    take_letter_backup(compound)
+    return_bool = True if letter_singleton_source.is_compound else False
+    restore_letter_backup()
+    return return_bool
+
+def is_aytham(aytham):
+    if aytham == "ஃ":
+        return True
+    else:
+        return False
+
+def constant(letter):
+    take_letter_backup(letter)
+    return_constant = letter_singleton_source.constant 
+    restore_letter_backup()
+    return return_constant
+
+def vowel(letter):
+    take_letter_backup(letter)
+    return_constant = letter_singleton_source.voule  
+    restore_letter_backup()
+    return return_constant
+
+def hard_constant(letter):
+    take_letter_backup(letter)
+    constant_letter = letter_singleton_source.constant 
+    return_constant = None
+    for related , constant in zip(HARD_CONSTAND,SOFT_CONSTANT):
+        if constant_letter == constant:
+            return_constant = related 
+            break
+    restore_letter_backup()
+    return return_constant
+
+def soft_constant(letter):
+    take_letter_backup(letter)
+    constant_letter = letter_singleton_source.constant 
+    return_constant = None
+    for related , constant in zip(SOFT_CONSTANT,HARD_CONSTAND):
+        if constant_letter == constant:
+            return_constant = related 
+            break
+    restore_letter_backup()
+    return return_constant 
+
+def get_constants(value,index=False):
+    take_string_backup(value)
+    return_list = []
+    for indces, letter in enumerate(string_singleton_source.capsules):
+        if letter[-1] == "CON":
+            return_list.append([indces,letter[1]])
+    restore_letter_backup()
+    if index:
+        return return_list
+    else:
+        return [ each[-1] for each in return_list ]
+
+def get_vowels(value,index=False):
+    take_string_backup(value)
+    return_list = []
+    for indces, letter in enumerate(string_singleton_source.capsules):
+        if letter[-1] == "VOL":
+            return_list.append([indces,letter[1]])
+    restore_letter_backup()
+    if index:
+        return return_list
+    else:
+        return [ each[-1] for each in return_list ]
+
+def get_compounds(value,index=False):
+    take_string_backup(value)
+    return_list = []
+    for indces, letter in enumerate(string_singleton_source.capsules):
+        if letter[-1] == "COM":
+            return_list.append([indces,letter[1]])
+    restore_letter_backup()
+    if index:
+        return return_list
+    else:
+        return [ each[-1] for each in return_list ]
+
+def get_tamil(string,only=[]):
+    take_string_backup(string)
+    return_list = []
+    for letter in string_singleton_source.capsules:
+        if letter[0] == "ta":
+            if letter[-1] in only:
+                return_list.append(letter)
+            else:
+                return_list.append(letter)
+    restore_string_backup()
+    return capsule_letter(return_list)
+
+def get_english(string,only=[]):
+    take_string_backup(string)
+    return_list = []
+    for letter in string_singleton_source.capsules:
+        if letter[0] == "en":
+            if letter[-1] in only:
+                return_list.append(letter)
+            else:
+                return_list.append(letter)
+    restore_string_backup()
+    return capsule_letter(return_list)
+
+def get_sanskrit(string,only=[]):
+    take_string_backup(string)
+    return_list = []
+    for letter in string_singleton_source.capsules:
+        if letter[0] == "sa":
+            if letter[-1] in only:
+                return_list.append(letter)
+            else:
+                return_list.append(letter)
+    restore_string_backup()
+    return capsule_letter(return_list)
+
+def get_tamil_numerals(string):
+    take_string_backup(string)
+    return_list = []
+    for letter in string_singleton_source.capsules:
+        if letter[0] == "ta":
+            if letter[-1] == "NUM":
+                return_list.append(letter)
+    restore_string_backup()
+    return capsule_letter(return_list)
+
+def get_tamil_symbols(string):
+    take_string_backup(string)
+    return_list = []
+    for letter in string_singleton_source.capsules:
+        if letter[0] == "ta":
+            if letter[-1] == "CAR":
+                return_list.append(letter)
+    restore_string_backup()
+    return capsule_letter(return_list)
+
+def capsule_letter(capsules):
+    if isinstance(capsules,tuple):
+        return capsules[1]
+    else:
+        return_letters = []
+        for letter in capsules:
+            return_letters.append(letter[1])
+        return return_letters
+
+def take_letter_backup(value):
+    if isinstance(value, Letter):
+        letter_singleton_backup = value.letter
+        letter_singleton_source.letter = value
+    else:
+        if letter_singleton_source.letter != None:
+            letter_singleton_backup = letter_singleton_source.letter
+        letter_singleton_source.letter = value
+
+def restore_letter_backup():
+    letter_singleton_source.letter =letter_singleton_backup
+
+def take_string_backup(value):
+    if isinstance(value, String):
+        string_singleton_backup = value.string
+        string_singleton_source.string = value
+    else:
+        if string_singleton_source.string != None:
+            string_singleton_backup = string_singleton_source.string
+        string_singleton_source.string = value
+  
+def restore_string_backup():
+    string_singleton_source.string = string_singleton_backup

tamilstring/helper.py

@@ -0,0 +1,395 @@
+from . import utf8 
+
+
+class Letter:
+    _instance = None  
+    def __new__(cls, *args, **kwargs):
+        singleton = kwargs.pop('singleton', False)
+        if singleton:
+            if cls._instance is None:
+                cls._instance = super().__new__(cls)
+                cls._instance._initialized = True
+            return cls._instance
+        else: 
+            return super().__new__(cls)
+
+    def __init__(self, *args, **kwargs):
+        if not getattr(self, '_initialized', True):
+            super().__init__(*args, **kwargs)
+            self._initialized = True 
+        if len(args) == 1:
+            args1 = args[0]
+            if isinstance(args1, str):
+                args1 = str(args1)
+            self.__root = utf8.get_letters(args1,capsule=True)[0]
+        else:
+            self.__root = None
+        self.output = kwargs.pop('obj', False)
+        
+    def __add__(self,other):        
+        if not isinstance(other,Letter):
+            other_letters =  utf8.get_letters(other,capsule=True)
+            if len(other_letters) != 1: 
+                other = take_string_backup(other)
+            else:
+                other = take_letter_backup(other)
+        if not isinstance(other, Letter):
+            if self.is_constant and other.singleton(0).is_voule:
+                other.string = utf8.make_compound(self.letter,other.singleton(0).letter) + other[1:]
+                return other if self.output else other.string
+            else:
+                other.string = self.letter+other[:]
+                return other if self.output else other.string
+        if self.is_constant and other.is_voule:
+            other = utf8.make_compound(self.letter,other.letter)
+            return Letter(other) if self.output else other
+        else:
+            other = self.letter + other.letter
+            return String(other) if self.output else other
+            
+    def __sub__(self, other):
+        if  not isinstance(other,Letter):
+            other_ =  utf8.get_letters(other)
+            if len(other_) != 1:
+                raise ValueError("only tamil letter can be add.")
+            else:
+                other = Letter(other)
+        if self.is_compound:
+            if other.is_constant or other.is_voule:
+                if other.is_voule:
+                    return Letter(self.constant) if self.output else self.constant
+                elif other.is_constant:
+                    return Letter(self.voule)  if self.output else self.voule           
+            else:
+                raise ValueError("voule or constant can subract only from compound")     
+        else:
+            raise ValueError("non compound kind can not subractable")
+
+    def __contains__(self, item):
+        if item in self.letter:
+            return True
+        else:
+            return False
+
+    def __str__(self):
+        return self.letter
+    
+    def root(self,index): 
+        if self.__root != None: 
+            return self.__root[index]
+        else:
+            return None
+
+    @property
+    def kind(self): 
+        return self.root(-1)
+
+    @property
+    def lang(self): 
+        return self.root(0)
+
+    @property
+    def letter(self):
+        return self.root(1)
+
+    @letter.setter
+    def letter(self, value):
+        if value != None:
+            self.__root = utf8.get_letters(value,capsule=True)[0] 
+        else:
+            self.__root = None
+
+    @property
+    def capsule(self):
+        return self.__root
+
+    @capsule.setter
+    def capsule(self, value):
+        self.__root = value
+        # TODO to change _root sting
+ 
+    @property
+    def is_voule(self):
+        if self.kind == 'VOL':
+            return True
+        else:
+            return False
+        
+    @property
+    def is_constant(self):
+        if self.kind == 'CON':
+            return True
+        else:
+            return False
+        
+    @property
+    def is_compound(self): 
+        if self.kind == 'COM':
+            return True
+        else:
+            return False
+    
+    @property
+    def has_voule(self):
+        if self.kind == "VOL" or self.kind == "COM":
+            return True
+        else:
+            return False
+        
+    @property
+    def has_constant(self):
+        if self.kind == "TA_CON" or self.kind == "COM":
+            return True
+        else:
+            return False
+    
+    @property
+    def voule(self):
+        if self.kind == "VOL":
+            return self.letter
+        elif self.kind == "COM":
+            constant_ , voule_ = utf8.split_compound(self.letter)
+            return voule_
+        else:
+            return None
+        
+    @property
+    def constant(self):
+        if self.kind == "CON":
+            return self.letter
+        elif self.kind == "COM":
+            constant_ , voule_ = utf8.split_compound(self.letter)
+            return constant_
+        else:
+            return None
+          
+    @property
+    def compound(self):
+        if self.kind == "COM":
+            return self.letter
+        else:
+            return None
+            
+    @property
+    def split_letter(self):
+        return utf8.split_compound(self.letter)
+    
+    def contain(self, other):
+        if len(other) > 2:
+            raise ValueError("it does not look like a seperate letter")
+        if not isinstance(other, Letter):
+            other = Letter(other)
+        if other.kind == self.kind:
+            if other.letter == self.letter:
+                return True
+            else:
+                return False
+        elif (other.is_compound and not self.is_compound):
+            return None
+        elif (self.is_compound and not other.is_compound) :
+            if other.letter in self.splitLetter:
+                return True
+            else:
+                return False
+
+    def get_match(self, other, output=False):
+        if not isinstance(other,Letter):
+            other = Letter(other)
+        output_value = (False,None,None) 
+        if self.letter == other.letter:
+            output_value = (True,other.kind,"EXACT")
+        elif (other.is_compound and not self.is_compound):
+            if self.letter in other.split_letter[0]:
+                output_value = (True,other.kind,"CONTAINS")
+        elif (self.is_compound and not other.is_compound):
+            if other.letter == self.split_letter[1]:
+                output_value = (True,other.kind, "CONTAINS")
+        if output:
+            return output_value
+        else:
+            return output_value[0]
+
+
+class String:       
+    _instance = None  
+
+    def __new__(cls, *args, **kwargs):
+        singleton = kwargs.pop('singleton', False)
+        if singleton:
+            if cls._instance is None:
+                cls._instance = super(String, cls).__new__(cls)
+                cls._instance._initialized = True 
+            return cls._instance
+        else:
+            return super(String, cls).__new__(cls)
+
+    def __init__(self, *args, **kwargs):
+        if not getattr(self, '_initialized', True):
+            super(String, self).__init__(*args, **kwargs)
+            self._initialized = True 
+        if len(args) == 1:
+            args1 = args[0]
+            if isinstance(args1, str):
+                args1 = str(args1)
+            self.__root = args1
+        else:
+            self.__root = None
+        self.output = kwargs.pop('obj', False)
+        self.position = 0
+
+    def __add__(self,other):
+        if not isinstance(other,String):
+            other = String(other)
+        if self.singleton(-1).is_constant and other.singleton(0).is_voule:
+            ret = String("".join(self.letters[:-1] + [ utf8.make_compound(self.letters[-1],
+                other.letters[0])] + other.letters[1:] ) )
+            return ret if self.output else ret.string
+        else:
+            ret = String("".join(self.letters + other.letters))
+            return ret if self.output else ret.string
+            
+    def __sub__(self,other):
+        if not isinstance(other, Letter):
+            other = Letter(other)
+        if isinstance(other, Letter):
+            if self.singleton(-1).is_compound and ( other.is_voule or other.is_constant): 
+                final_letter = self.singleton(-1).constant if other.kind == "VOL" else self.singleton(-1).voule
+                ret =  String("".join( self.letters[:-1] ) + final_letter)
+                return ret if self.output else ret.string
+            else:
+                raise ValueError("can only subract string endings with voule or constant")        
+        else:
+            raise ValueError("can only subract string endings with voule or constant")
+
+    @property
+    def letters(self):
+        return [l[1] for l in self.capsules]
+
+    @property
+    def capsules(self):
+        return utf8.get_letters(self.__root,capsule=True)
+
+    @property
+    def string(self):
+        return self.__root
+
+    @string.setter
+    def string(self,value):
+        self.__root = value
+       
+    def has_contain(self, substring,):
+        if isinstance(substring, String):
+            subString = substring
+        else:
+            subString = String(substring)    
+        matchValue, all_matches = [] ,[]       
+        matchCount,tracer = 0,0
+        letter = Letter('ஆ',obj=True)
+        print(self.string,subString.string) 
+        for index , letter_ in enumerate(self.capsules):
+            letter.capsule = letter_
+            if matchCount == len(subString.letters):
+                subString.position,matchCount= 0,0
+                all_matches.append((True,matchValue)) 
+                matchValue = []
+                tracer = index
+            checkMatch =  letter.get_match(subString[subString.position],output=True )
+            if checkMatch[0]:
+                if checkMatch[-1] == "EXACT": 
+                    matchValue.append(letter_[1])
+                    subString.position += 1 
+                    matchCount += 1
+                    
+                if checkMatch[-1] == "CONTAINS": 
+                    constant,voule = letter.split_letter
+                    if checkMatch[1] == "VOL":                       
+                        matchValue.append(voule)
+                        if len(all_matches) != 0:
+                            if all_matches[-1][0] == True:
+                                all_matches.append((False,constant))
+                            else:
+                                all_matches[-1] = (False,all_matches[-1][0]+[constant])
+                        subString.position += 1  
+                        matchCount += 1
+            else:
+                if index == tracer:
+                    all_matches.append( (False,[l for l in self.letters[tracer:index+1]]) )
+                else:
+                    all_matches[-1] = (False,[l for l in self.letters[tracer:index+1]])
+            self.position = index
+        return [(am[0],"".join(am[1]) ) for am in all_matches ]
+         
+    def index_obj(self,index):
+        return Letter(self.letters[index])
+
+    def singleton(self,index,singleton = False):
+        return Letter(self.letters[index],singleton = True)
+    
+    def letter(self,index):
+        return Letter(self.letters[index])
+ 
+    def __getitem__(self, index):
+        if isinstance(index, slice):
+            if self.string:
+                return "".join(self.letters[index.start:index.stop:index.step])
+            else:
+                return "".join(self.letters[index.start:index.stop:index.step])
+        else:
+            return self.letters[index]
+
+    def __setitem__(self, index, value):
+        if isinstance(index, slice):
+            start, stop, step =  index.indices(len(self.letters))   
+            previous_value = self.letters
+            if not isinstance(value, String):
+                other = String(value,singleton = True)
+            previous_value[start:stop:step] = other.letters
+            self.string = "".join(previous_value)   
+        else:
+            previous_value = self.letters 
+            previous_value[index] = value
+            self.string = "".join(previous_value)   
+
+
+    def __delattr__(self):
+        del self
+
+    def __iter__(self):
+        return iter(self.letters)
+    
+    def __len__(self):
+        return len(self.letters)
+
+    def __contains__(self, other):        
+        if not isinstance(other,str):
+            other = str(other)
+        if self.__root in other:
+            return True
+        else:
+            return False
+
+
+letter_singleton_source = Letter(singleton = True)   
+letter_singleton_backup = None
+
+def take_letter_backup(letter):
+    if letter_singleton_source.letter != None:
+        letter_singleton_backup = letter_singleton_source.letter 
+    letter_singleton_source.letter = letter
+    return letter_singleton_source
+    
+def restore_letter_backup():
+    letter_singleton_source.letter = letter_singleton_backup
+
+
+string_singleton_source = String(singleton = True)   
+string_singleton_backup = None
+
+def take_string_backup(sting):
+    if string_singleton_source.string != None:
+        string_singleton_backup = string_singleton_source.string 
+    string_singleton_source.string = sting
+    return string_singleton_source
+    
+def restore_string_backup():
+    string_singleton_source.string = string_singleton_backup

tamilstring/utf8.py

@@ -0,0 +1,150 @@
+from .constant import VOULES_LET,VOULES_SYM
+
+def english_range(code,specify=False):
+    letter = None
+    if 0x0000 <= code <= 0x007E:
+        if 0x41 <= code <= 0x5A:
+            letter = "UPP" 
+        elif 0x61 <= code <= 0x7A:
+            letter = "LOW"
+        elif 0x30 <= code <= 0x39:
+            letter = "NUM"
+        elif code < 0x80: 
+            letter = "SYM"
+    if specify:
+        return letter if letter != None else False
+    else:
+        return True if letter != None else False
+
+def in_range(code):
+    if 0x0B80 <= code <= 0x0BFF:
+        return True
+    else:
+        return False
+
+def tamil_range(code,specify=False):
+    letter = None
+    if in_range(code):
+        if code == 0x0BCD or code == 0x0B82:
+            letter = "CON"
+        elif 0x0B85 <= code <= 0x0B94:
+            letter = "VOL"
+        elif 0x0B95 <= code <= 0x0BB9:
+            if code == 0x0B9C or 0x0BB6 <= code <=0x0BB9:
+                pass
+            else:
+                letter = "COM" 
+        elif 0x0BBE <= code <= 0x0BCC:
+            letter = "UNI"
+        elif 0x0BE6 <= code <= 0x0BEF:
+            letter = "NUM"
+        elif 0x0BF1 <= code <= 0x0BFA:
+            letter = "CAR" 
+        elif code == 0x0B83:
+            letter = "AUT"
+
+    if specify:
+        return letter if letter != None else False
+    else:
+        return True if letter != None else False
+ 
+def sanskrit_range(code,specify=False):
+    letter = None
+    if in_range(code):
+        if code == 0x0B9C or 0x0BB6 <= code <=0x0BB9:
+            letter = "COM" 
+    if not specify:
+        return letter
+    else:
+        return True if letter != None else False
+
+def get_letters(string,capsule=False,error=True):
+    rt = []
+    previous_compound = None
+    for index,char in enumerate(string):
+        code = ord(char ) 
+         
+        english = english_range(code,specify=True)
+        if english != False:
+            rt.append(("en",char,english)) 
+            continue
+        
+        tamil = tamil_range(code,specify=True)
+        if tamil != False:
+            if tamil == "VOL":
+                rt.append(("ta",char,"VOL"))
+            elif tamil == "UNI":
+                last = rt[-1] if rt else None
+                if last != None:
+                    if last[-1] == "COM":
+                        rt[-1] = (last[0] ,last[1]+char, "COM")
+                    if last[1] == "ஶ்ர":
+                        rt[-1] = (last[0] ,last[1]+char, "SYM")
+            elif tamil == "CON":
+                last = rt[-1] if rt else None
+                if last != None:
+                    if last[-1] == "COM":
+                        rt[-1] = (last[0] ,last[1]+char, "CON")
+            elif code == 0x0BB0:
+                last = rt[-1] if rt else None
+                if last != None:
+                    if last[1] == "ஶ்":
+                        rt[-1] = ("sa" ,last[1]+char, "SYM")
+                    else:
+                        rt.append(("ta",char,tamil ))
+            else:
+                rt.append(("ta",char,tamil ))
+            continue
+
+        sanskrit = sanskrit_range(code,specify=True)
+        if sanskrit != None:
+            if code == 0x0BB7:
+                last = rt[-1] if rt else None
+                if last != None:
+                    if last[1] == "க்":
+                        rt[-1] = ("sa" ,last[1]+char, "COM")
+                else:
+                    rt.append( ("sa",char,"COM" ) )
+            else:
+                rt.append( ("sa",char,"COM" ) )
+        else:
+            rt.append(("~",char,"UNK"))
+
+    if capsule:
+        return rt
+    else:
+        return [ letter[1] for letter in rt]
+
+def remove_voule(letter):
+    pass
+
+def split_compound(letter, strict=True):
+    letter = get_letters(letter, capsule=True)[0]
+    if letter[-1] == "COM":
+        for voule_let, voule_sym in zip(VOULES_LET[1:],VOULES_SYM):
+            if letter[1][-1] == voule_sym:
+                return (letter[1][:-1]+'்', voule_let)
+        else:
+            return (letter[1]+'்', "அ")
+    else:
+        return None
+
+def make_compound(letter1,letter2):
+    letter1 = get_letters(letter1, capsule=True)
+    letter2 = get_letters(letter2, capsule=True)
+    if len(letter1) == 1 and len(letter2) == 1:
+        letter1 , letter2 = letter1[0] , letter2[0]
+        if (letter1[-1] == "CON" and letter2[-1] == "VOL") or (letter1[-1] == "VOL" and letter2[-1] == "CON"):
+            constant = letter1 if letter1[-1] == "CON" else letter2
+            constant = constant[1][:-1]
+            voule = letter1 if letter1[-1] == "VOL" else letter2
+            voule = voule[1][-1]
+            for voule_let, voule_sym in zip(VOULES_LET[1:],VOULES_SYM):
+                if voule == voule_let:
+                    return constant + voule_sym
+            else:
+                return constant
+        else:
+            raise ValueError("unjoinable letter types")
+    else:
+        raise ValueError("more then two letter in any one parameter")

tamilstring-0.3.25.dist-info/LICENCE

@@ -0,0 +1,26 @@
+
+### 4. Add a `LICENSE`
+Choose a license for your project and add a `LICENSE` file. For example, if you choose the MIT License, your `LICENSE` file might look like this:
+
+```text
+MIT License
+
+Copyright (c) [year] [fullname]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tamilstring-0.3.25.dist-info/METADATA

@@ -0,0 +1,31 @@
+Metadata-Version: 2.2
+Name: tamilstring
+Version: 0.3.25
+Summary: tamilstring helps to handle tamil unicode characters lot more easier
+Home-page: https://gitlab.com/boopalan-dev/tamilstring
+Author: boopalan
+Author-email: contact.boopalan@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENCE
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: provides-extra
+Dynamic: requires-python
+Dynamic: summary
+
+# TamilString
+
+tamilstring helps to handle tamil unicode characters lot more easier.
+
+raise you issiues here => https://gitlab.com/boopalan-dev/tamilstring
+

tamilstring-0.3.25.dist-info/RECORD

@@ -0,0 +1,10 @@
+tamilstring/__init__.py,sha256=DJloBmU0XnBf-3XH_RD5rtoYHwWEqzRW_LzlRq-xEao,66
+tamilstring/constant.py,sha256=zxyD3AtyF0sQY5RiN56up7Hf1MTLFMwhU-B99gM7rIo,1305
+tamilstring/func.py,sha256=nQmk8Dl_BBmbzqxAwvjQxxJhGgfiBakhaoCyN4_hwww,7125
+tamilstring/helper.py,sha256=rwT_0R6So4DSbTO0XI0RuwW2bDFLb-I-CBcwG6reWas,13161
+tamilstring/utf8.py,sha256=S6vSvwVvHD3TCPrtCF36937mve2zCrDUic4CnoDcgUs,4946
+tamilstring-0.3.25.dist-info/LICENCE,sha256=AAxMH13pEByqrNic6bn1_UTH-u8QSNfjTdRgleNTd9Y,1247
+tamilstring-0.3.25.dist-info/METADATA,sha256=I9Z-RmjxAXcov57eHGRSWg1fOoSSbNKDEhkN1qii-Rk,897
+tamilstring-0.3.25.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+tamilstring-0.3.25.dist-info/top_level.txt,sha256=rS4SPFfzZjjtC3Cd-q0hatYgminewYspKC0xjimajHI,12
+tamilstring-0.3.25.dist-info/RECORD,,

tamilstring-0.3.25.dist-info/WHEEL

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

tamilstring-0.3.25.dist-info/top_level.txt

@@ -0,0 +1 @@
+tamilstring