path: root/gstudio/CNL.py

from gstudio.models import *
from django.template.defaultfilters import slugify
import inflect
import os

def get_CNL_list(self):
	x = []
	a = get_lex_sentence(self)
	if not a:
		pass
	else:
		x.extend(a)
	b = lex_sentence_optional(self)
	if not b:
		pass
	else:
		x.extend(b)
	c = contains_subtypes_sentence(self)
        if not c:
		pass
	else:
		x.extend(c)
	d = typeof_sentence(self)
	if not d:
		pass
	else:
		x.extend(d)
	e = get_CNL_dependency(self)
	if not e:
		pass
	else:
		x.extend(e)
	f = get_rel(self)
	if not f:
		pass
	else:
		x.extend(f)
	g = get_attr_sentence(self)
	if not g:		
		pass
	else:
		x.extend(g)
	return x


def advanced_CNL(self):
	y = []
	h = get_leftST_sentence(self)	
	if not h:                
		pass
	else:
		y.extend(h)
	i = get_rightST_sentence(self)
	if not i:
		pass
	else:
		y.extend(i)
        j = get_ST_sentence(self)
	if not j:
		pass
	else:
		y.extend(j)
	k = get_CNL_sentence_authors(self)
	if not k:
		pass
	else:
		y.extend(k)
        """To generate CNL data about RT/R"""	
        a = get_RT_sentence(self)
        if not a:
               pass
        else:
               y.extend(a)
	return y

#Returns lex sentence - Title 
def get_lex_sentence(self):  
    if self.ref.__class__.__name__ is 'Relationtype' or self.ref.__class__.__name__ is 'Attribute':
       pass
    else:      
       # If AT or RT       
       at = []
       if self.title:
           title = slugify(self.title)
           title_slug = slugify(title)
           if self.ref.__class__.__name__ is 'Attributetype' or self.ref.__class__.__name__ is 'Objecttype':
                g = "A "+str(title_slug).lower()+" is a common-noun."                       
           elif self.ref.__class__.__name__ is 'Metatype':                 
                g = "A "+str(title_slug).lower()+" is a metatype."    
              
           at.append(g)        
       return at

#Returns CNL sentences - Plural & Alternate names
def lex_sentence_optional(self): 
      
      # If AT, MT or OT
      a = []
      if self.ref.__class__.__name__ is 'Attribute' or self.ref.__class__.__name__ is 'Relationtype':
	pass
      elif self.ref.__class__.__name__ is 'Attributetype' or self.ref.__class__.__name__ is 'Objecttype' or self.ref.__class__.__name__ is 'Metatype':
         title_slug = slugify(self.title)
         if self.altnames:
           alt = self.altnames
           alt_slug = slugify(alt)
           e = "A "+str(alt_slug)+" is an alternate name for it."
           a.append(e.capitalize())
      
      # If MT or OT
      if self.ref.__class__.__name__ is 'Objecttype' or self.ref.__class__.__name__ is 'Metatype':
         if self.plural:
           plu_slug = slugify(self.plural)
           m="Some "+str(plu_slug)+" are a plural of a "+str(title_slug)+"."
           a.append(m.capitalize())
      return a    

#Generates CNL sentence for RT for which OT or MT is the left-subjecttype
def get_leftST_sentence(self):    
    if self.ref.__class__.__name__ is 'Attributetype' or self.ref.__class__.__name__ is 'Relationtype' or self.ref.__class__.__name__ is 'Attribute':
         pass     
    else:
      #If OT or MT
      cns=self.ref.get_nbh
      d = []
      for k in cns:
         title = str(cns['title'])
         title_slug = slugify(title)
         if self.ref.__class__.__name__ is 'Objecttype' or 'Metatype':
           if k == 'left_subjecttype_of':
               if not cns[k]:
                     pass
               else:                 
                   l_s_a = []
                   l_s_a = self.left_subjecttype_of.all() 
                   len_lsa=len(l_s_a)                   
                   if len_lsa == 1:
                     #If singular:
                     for each in l_s_a:                     
                       al=slugify(each) 
                       #A person is a n:left_subjecttype of a n:relation_type a:teaches and a:student-of and a:sibling-of and a:friend-of.    
                       if self.ref.__class__.__name__ is 'Objecttype':                                    
                          c = "A "+str(title_slug)+" is a left_subjecttype of a relation_type "+str(al)+"."  
                       elif self.ref.__class__.__name__ is 'Metatype':
                          c = "A "+str(title_slug)+" is a left_subjecttype of a relation_type "+str(al)+"." 
                       d.append(c.capitalize())
                                         
                   else:                     
                       #If plural:
                       y=[]
                       for each in self.left_subjecttype_of.all():                             
                             a=each
                             a_slug=slugify(a)
                             y.append(a_slug)
                       for e_i in y:                            
                             if y.index(e_i) == 0:
                                sen = str(e_i)
                             else:
                                sen = str(sen)+" and "+str(e_i)                  
                       if self.ref.__class__.__name__ is 'Objecttype':
                            c = "A "+str(title_slug)+" is a left_subjecttype of a relation_type "+sen+"."                       
                       elif self.ref.__class__.__name__ is 'Metatype':
                            c = "A "+str(title_slug)+" is a left_subjecttype of a relation_type "+sen+"."     
                       
                       d.append(c.capitalize())
      return d   

#Generates CNL sentence for RT for which OT or MT is the right-subjecttype
def get_rightST_sentence(self):    
    if self.ref.__class__.__name__ is 'Attributetype' or self.ref.__class__.__name__ is 'Relationtype' or self.ref.__class__.__name__ is 'Attribute':
         pass     
    else:
      #If OT or MT
      cns=self.ref.get_nbh
      d = []
      for k in cns:
          title = str(cns['title'])
          title_slug = slugify(title)
          if self.ref.__class__.__name__ is 'Objecttype' or self.ref.__class__.__name__ is 'Metatype':
            if k == 'right_subjecttype_of':
               if not cns[k]:
                     pass
               else:                 
                   r_s_a = []
                   r_s_a = self.right_subjecttype_of.all() 
                   len_rsa=len(r_s_a)                   
                   if len_rsa == 1:
                     #If singular:
                     for each in r_s_a:                     
                       al=slugify(each)     
                       if self.ref.__class__.__name__ is 'Objecttype':                                    
                          c = "A "+str(title_slug)+" is a right_subjecttype of a relation_type "+str(al)+"."  
                       elif self.ref.__class__.__name__ is 'Metatype':
                          c = "A "+str(title_slug)+" is a right_subjecttype of a relation_type "+str(al)+"." 
                       d.append(c.capitalize())
                                         
                   else:
                     #If plural:
                       y=[]
                       for each in self.right_subjecttype_of.all():                             
                             a=each
                             a_slug=slugify(a)
                             y.append(a_slug)
                       for e_i in y:                            
                             if y.index(e_i) == 0:
                                sen = str(e_i)
                             else:
                                sen = str(sen)+" and "+str(e_i)                  
                       if self.ref.__class__.__name__ is 'Objecttype':
                            c = "A "+str(title_slug)+" is a right_subjecttype of a relation_type "+sen+"."                       
                       elif self.ref.__class__.__name__ is 'Metatype':
                            c = "A "+str(title_slug)+" is a right_subjecttype of a relation_type "+sen+"."     
                       
                       d.append(c.capitalize())
      return d   

#Generates Subject-type sentence for AT
def get_ST_sentence(self):
     if self.ref.__class__.__name__ is 'Attribute':
	pass
     elif self.ref.__class__.__name__ is 'Attributetype':
        a = []
        if self.subjecttype:     
           subjecttype = self.subjecttype
           st_type = subjecttype.ref.__class__.__name__
           if st_type == 'Gbobject':
              c = str(subjecttype)+" is a subject_type_name for it."
           else:
              c = "A "+str(subjecttype)+" is a subject_type_name for it."
           a.append(c.capitalize())
        return a 


#Generates contains-subtypes for MT or OT
def contains_subtypes_sentence(self):          
    if self.ref.__class__.__name__ is 'Metatype' or self.ref.__class__.__name__ is 'Objecttype' or self.ref.__class__.__name__ is 'Attribute':
	pass
    elif self.ref.__class__.__name__ is 'Metatype' or self.ref.__class__.__name__ is 'Objecttype':
        #print "is a mt or OT"
	#print "it just entered the loop"
        cns=self.ref.get_nbh
        d = []
        for k in cns:
          title = str(cns['title'])
          title_slug = slugify(title)
          if k=='contains_subtypes':              
                 if not cns[k]:
                    pass
                 else:
                    if self.ref.__class__.__name__ is 'Metatype':
                       nof=self.children.get_query_set()                    
                    elif self.ref.__class__.__name__ is 'Objecttype':       
                       nof=Nodetype.objects.filter(parent=self.id)         
 	            len_nof=len(nof)
                    #print "nof----" ,nof   
                    #print len_nof, "len - nof"                                 
                    if len_nof == 1:
                      for each in nof:                     
                        nf=slugify(each) 
                        l = "A "+str(nf)+" is a subtype of a "+str(title_slug)+"."
                        d.append(l.capitalize())                                        
                    else:
                       #print "len not 1"
                       y=[]
                       for each in nof:                             
                             a=each
                             a_slug=slugify(a)
                             y.append(a_slug)
                       for e_i in y:                             
                             if y.index(e_i) == 0:
                                sen = str(e_i)
                             else:
                                sen = str(sen)+" and a "+str(e_i)                 

                       l = "A "+sen+" are some subtypes of "+str(title_slug)+"."                      
                       d.append(l.capitalize())
        return d  

#Generates Type-Of sentence for OT or MT
#get_nbh type_of --- Metatype
def typeof_sentence(self):       
   d = []
   if self.ref.__class__.__name__ is 'Relationtype' or self.ref.__class__.__name__ is 'Attributetype' or self.ref.__class__.__name__ is 'Attribute':
     pass
   elif self.ref.__class__.__name__ is 'Objecttype' or self.ref.__class__.__name__ is 'Metatype':
     #print "mt or ot"
     cns = self.ref.get_nbh
     for k in cns:
       title = str(cns['title'])
       title_slug = slugify(title)
       if k=='type_of':
                 if not cns[k]:
                     pass
                 else:                   
                   if self.ref.__class__.__name__ is 'Objecttype':                     
                     n = self.parent
		     n_slug=slugify(n)
                   elif self.ref.__class__.__name__ is 'Metatype':                      
                     n = str(cns[k])                    
                     n_slug=slugify(n)
                   an = "A "+str(title_slug)+" is a type of a "+str(n_slug)+"."                   
                   d.append(an.capitalize())
                 return d

#Generates CNL Sentence - Prior & Posterior Nodes
def get_CNL_dependency(self): 
    if self.ref.__class__.__name__ is 'Attribute':
	pass   
    elif self.ref.__class__.__name__ is 'Objecttype' or self.ref.__class__.__name__ is 'Attributetype' :      
      title = self.title
      title_slug = slugify(title)
      d=[]                          
      if self.prior_nodes.all():
                   p_n_a = [] 
                   p_n_a = self.prior_nodes.all()
                   #print len(p_n_a)
                   len_pna=len(p_n_a)                   
                   if len_pna == 1:
                     for each in p_n_a:                     
                       pn=slugify(each)                                       
                       h="A "+str(title_slug)+" depends on a "+str(pn)+"."
                       d.append(h.capitalize()) 
                   else:                       
                       sen = dependency_plural(p_n_a)
                       h = "A "+str(sen)+". It is required for the meaning of a "+str(title_slug)+"."
                       d.append(h)
      
      if self.posterior_nodes.all():                
                   p_n_a = []
                   p_n_a = self.posterior_nodes.all() 
                   #print "length of posterior nodes-----" ,len(p_n_a)
                   len_pna=len(p_n_a)                   
                   if len_pna == 1:
                     for each in p_n_a:                     
                       pn = slugify(each)                                         
                       p = "A "+str(title_slug)+" is required for the meaning of a "+str(pn)+"."
                       d.append(p.capitalize()) 
                   else:                      
		       sen = dependency_plural(p_n_a)
                       p = "A "+str(sen)+". It depends on "+str(title_slug)+"."
                       d.append(p)
      return d

#Generates dependency sentence for plural
def dependency_plural(p_n_a):                                              
                      y=[]
                      #print "len not 1"
                      for each in p_n_a:
                         each_r = each.ref.__class__.__name__
                         apn = each
                         apn_slug = slugify(apn)
                         if len(y) == 0:
                                "If Y is empty, for first item"
                                if each_r == 'Relationtype':
                                    b_slug = str(apn_slug)+" is an adjective" 
                                else:
                                    b_slug = str(apn_slug)+" is a common-noun"
                                y.append(b_slug)
                         else:
                                if each_r != 'Relationtype':
                                   #print "Its not a relation_type, but a noun, so appending an 'a' "
                                   aa_slug = "a "+str(apn_slug)+" is a common-noun"
                                   y.append(aa_slug)
                                else:
                                   #print "It is a relationtype"
                                   ab_slug = str(apn_slug)+" is an adjective"
                                   y.append(ab_slug)
                      for e_i in y:
                             if y.index(e_i) == 0:
                                sen = str(e_i).lower()
                             else:                             
                                sen = str(sen)+" and "+str(e_i).lower()  
                      return sen 



#Generates CNL sentence for authors, in OT and AT
def get_CNL_sentence_authors(self):      
      title = self.title
      title_slug = slugify(title)
      d=[]
      if self.ref.__class__.__name__ is 'Attribute':
	pass
      elif self.ref.__class__.__name__ is 'Objecttype' or self.ref.__class__.__name__ is 'Attributetype':
        if self.authors.all():
                   auth = []
                   auth = self.authors.all() 
 	           len_auth=len(auth)                   
                   if len_auth == 1:
                     for each in auth:                     
                       aut=slugify(each)                                         
                       e=str(aut).title()+" is an author to a "+str(title_slug)+"."
                       d.append(e.capitalize())                                         
                   else:
                       #print "len not 1"                       
                       y=[]
                       for each in self.authors.all():                             
                          a=each
                          a_slug=slugify(a)
                          y.append(a_slug)
                          for e_i in y:                             
                             if y.index(e_i) == 0:
                                sen = str(e_i)
                             else:
                                sen = str(sen)+" and "+str(e_i)

                          e = str(sen).title()+" are all chosen authors to a "+str(title_slug)+"."                       
                       d.append(e.capitalize())                       
      return d


    
         
	 

#Checks if RT-title is a transitive verb finite singular or an iterative adjective
def istv_title(self):        
        p = inflect.engine()
        from django.template.defaultfilters import slugify
        destination = open( "/home/user/gnowsys-studio/demo/aFile.pl", "r+"  )        
        f = destination.read()
        a_t = self.title
        a = slugify(a_t)               
        if '-' not in a:
            if a[-1] == 's':
                  a_s = p.singular_noun(a)
                  a_lex = "tv_finsg("+a+", "+str(a_s)+")."
                  strpos = f.find(a_lex)
                  if strpos != -1: 
                       return True
                  else:
                       return False

#Checks if RT-inverse is a transitive verb finite singular or an iterative adjective
def istv_inverse(self):
        p = inflect.engine()        
        destination = open( os.path.join(os.getcwd(),'aFile.pl'), "r+"  )        
        f = destination.read()
        a_t = self.inverse
        a = slugify(a_t)               
        if '-' not in a:
            if a[-1] == 's':
                  a_s = p.singular_noun(a)
                  a_lex = "tv_finsg("+a+", "+str(a_s)+")."
                  strpos = f.find(a_lex)
                  if strpos != -1: 
                       return True
                  else:
                       return False


#Returns attributes for the given OT
def get_attr_sentence(self):
   if self.ref.__class__.__name__ is 'Objecttype':
     from django.template.defaultfilters import slugify
     ot = self.get_attributes
     if not ot:
          pass
     else:
       a = []
       title = self.title
       title_slug = slugify(title)
       for k,v in ot.iteritems():
             attr = k
             for each in v:
                  value = each
       attr_slug = slugify(attr)
       sen = "The "+str(attr_slug)+" of a "+str(title_slug)+" is "+str(value)+"."
       a.append(sen)
       return a
   else:
     pass


def get_list_relation(self, lr):
      """Returns the list of relations"""     
      gbr = self.get_rendered_relations
      if not gbr:
            pass
      else:
          for k,v in gbr.iteritems():
               if k == 'lrelations':
                    val_l = v
               if k == 'rrelations':
                    val_r = v
          
          if lr == 0:
                return val_l
          elif lr == 1:
                return val_r

#Generating CNL for RT and Relations:
#(**Execute get_lex property to update new RT's in lexicon before executing CNL sentences.)
def get_CNL_sentence_RT(self, lst, rst, detail_level):      
      if self.ref.__class__.__name__ is 'Relationtype':
         core = [] #core data list
         core_t = []
         core_i = []
         reflexive = []
	 adv = [] # advanced data list             
         title=self.title
         title_slug=slugify(title)
         inverse=self.inverse
         inverse_slug=slugify(inverse)
         is_symmetrical=self.is_symmetrical
         is_reflexive=self.is_reflexive
         llist = []
         rlist = []
         llist = lst
         rlist = rst
         #print "lst",llist
         #print "rst",rlist
         #Flag variable that checks if plural or not
         plural_l = 0
         plural_r = 0
         #print "ll--",llist 
         #print "rr---",rlist
         if isinstance(llist,list):
            """If llist is a list"""
            ll = []
            for each in llist:                
                if each.ref.__class__.__name__ is not 'Gbobject':
                    """Common-noun"""
                    lst = "a "+str(each).lower()
                else:
                    """Proper-noun"""
                    lst = str(each).title()
                ll.append(lst)
		#print "ll",ll
            if len(ll) == 1:
                   for e in ll: 
                       left_subtype = e
		       #print "e in ll",left_subtype
            else: 
                   plural_l = 1 
                   for e in ll:
                        if ll.index(e)==0:
                             sen = str(e)
                        else:
                             sen = str(sen)+" and "+str(e)
                   left_subtype = sen                    
         else:
                 """If llist is not a list"""
                 lst=NID.objects.get(title=lst)
                 if lst.ref.__class__.__name__ is 'Gbobject':  
                     left_subtype = lst
                 else:
                     left_subtype = "a "+str(lst) 
         #print "left_subtype---",left_subtype  
         
         if isinstance(rlist,list):
            """If rlist is a list"""
            rl = []
            for each in rlist:                
                if each.ref.__class__.__name__ is not 'Gbobject':
                    """Common-noun"""
                    rst = "a "+str(each)
                else:
                    rst = each
                rl.append(rst)
            if len(rl) == 1:
                   for e in rl: 
                       right_subtype = e
                       #print "rst in e---",right_subtype
            else:  
                   plural_r = 1
                   for e in rl:
                        if rl.index(e)==0:
                             sen = str(e)
                        else:
                             sen = str(sen)+" and "+str(e)
                   right_subtype = sen                    
         else:
                 """If Rlist is not a list"""
                 if rst.ref.__class__.__name__ is 'Gbobject':
                    right_subtype = rst 
                 else:
                    right_subtype = "a "+str(rst)     
         #print "right_subtype---",right_subtype   
         
         
         #Core sentence - title       
         
         rel = rel_CNL(self, left_subtype, right_subtype, plural_l)
         #print rel, "the sentence"
         #print left_subtype
         #print right_subtype
         core_t.extend(rel)               
         
        
         rlex = rel_lex_sentence(self)
         adv.extend(rlex)
         #print "rlex---",rlex
 
         app_NT = get_app_NT(self)
         adv.extend(app_NT)
         #print "app_NT",app_NT
         
         st = get_RT_subjecttype(self, left_subtype, right_subtype)
         adv.extend(st)
         #print "st---",st
         
        
    
         #Is symmetrical
         if is_symmetrical:
            symm = is_symmetrical_RT(self, left_subtype, right_subtype, plural_r)
            core_i.extend(symm)               
            #print "symm---",symm
         
         else:
            asymm = is_asymmetrical_RT(self, left_subtype, right_subtype, plural_r)
            core_i.extend(asymm)
            #print "asymm--",asymm
         #Is reflexive 
         if is_reflexive:
           if detail_level == 1 or plural_l == 1:
                 st = right_subtype
           else:
                 st = left_subtype
           is_refl = is_reflexive_sentence(self, st)          
           core.extend(is_refl)
           reflexive.extend(is_refl)                              
           #print "is_refl" ,is_refl            
                    
         if detail_level==0:
               #Title,Reflexive
               for e in core_t:
                   a = e
               reflexive.insert(0, a)
               return reflexive
	 elif detail_level==1:
               #Inverse,reflexive
	       for e in core_i:
                    a = e
               reflexive.insert(0,a)
               return reflexive
         elif detail_level==2:
               #Title, Inverse & Reflexive
               core.extend(core_t)
               core.extend(core_i)
               core.extend(reflexive)
               return core
         elif detail_level==3:
               #Return advanced grammatical information
	       return adv
	 elif detail_level==4:
                #Return all info - Core & Advanced Info
	 	newlist = []
	 	newlist.extend(core)
	 	newlist.extend(adv)
	  	return newlist

def rel_CNL(self, left_subtype, right_subtype, plural_l):
   """To generate sentence for relation"""
   title = self.title
   title_slug = slugify(title)
   if self.ref.__class__.__name__ is 'Relationtype':
     rel = []
     if istv_title(self):
           st = str(left_subtype)+" "+str(title).lower()+" "+str(right_subtype)+"."
     else: 
        if plural_l == 0:
              st = str(left_subtype)+" is "+str(title).lower()+" "+str(right_subtype)+"."
        elif plural_l == 1:
              st = str(left_subtype)+" are "+str(title).lower()+" "+str(right_subtype)+"."
     rel.append(st.capitalize())
   return rel  
         
         
def is_reflexive_sentence(self, st):
      refl = []
      title = self.title
      title_slug = slugify(title)
      if istv_title(self): 
         j= "It is a reflexive sentence. "+str(st).title()+" "+str(title)+" "+str(st)+"."
      else:
         j= "It is a reflexive sentence. "+str(st).title()+" is "+str(title)+" "+str(st)+"."
      refl.append(j)  
      return refl

def is_symmetrical_RT(self, left_subtype, right_subtype, plural_r):
          """Generates CNL Sentence for Relation/RT if symmetrical"""
          symm = []
          title = self.title
          title_slug = slugify(title)
          if istv_title(self):
             g = str(right_subtype).title()+" "+str(title)+" "+str(left_subtype).title()+"."
          else:
            if plural_r == 0:
               g = str(right_subtype).title()+" is "+str(title)+" "+str(left_subtype).title()+"."  
            else:
               g = str(right_subtype).title()+" are "+str(title)+" "+str(left_subtype).title()+"."  
          symm.append(g.capitalize())
          return symm

def is_asymmetrical_RT(self, left_subtype, right_subtype, plural_r):
      """Generates CNL Sentence for Relation/RT if symmetrical"""
      asymm = []
      inverse = self.inverse
      inverse_slug = slugify(inverse)
      if istv_inverse(self):
             g = str(right_subtype).title()+" "+str(inverse)+" "+str(left_subtype).title()+"."
      else:
         if plural_r == 0:
             g = str(right_subtype).title()+" is "+str(inverse)+" "+str(left_subtype).title()+"."
         elif plural_r == 1:
             g = str(right_subtype).title()+" is "+str(inverse)+" "+str(left_subtype).title()+"."
      asymm.append(g.capitalize())          
      return asymm


def rel_lex_sentence(self):
   """Generates RT's title & inverse sentence"""
   if self.ref.__class__.__name__ is 'Relationtype':
      rlex = []
      title=self.title
      title_slug=slugify(title)
      inverse=self.inverse
      inverse_slug=slugify(inverse)
      h="A relation_type's title is "+str(title_slug)+"."
      rlex.append(h.capitalize())
      
      if (title==inverse):
             b="Its title and its inverse are equal."
      else:
             b="Its inverse is "+str(inverse_slug)+"."
      rlex.append(b.capitalize())
      return rlex


def get_app_NT(self):
     """Generates CNL Sentences for left & right applicable NT for RT"""
     if self.ref.__class__.__name__ is 'Relationtype':
         a = []
         l_app = self.left_applicable_nodetypes         
         r_app=self.right_applicable_nodetypes   
         e = "Its left_applicable_nodetype is "+str(l_app).upper()+"."
         a.append(e)
         
         f = "Its right_applicable_nodetype is "+str(r_app).upper()+"."
         a.append(f) 
         return a     
         
         
        
def get_RT_sentence(self):
       #Generates CNL Sentences in RT
       if self.ref.__class__.__name__ is 'Relationtype':
          sentence = get_CNL_sentence_RT(self, self.left_subjecttype, self.right_subjecttype, 4)
          return sentence  

       #Generates CNL sentences in Relation
       elif self.ref.__class__.__name__ is 'Relation':
          sentence = get_CNL_sentence_RT(self.relationtype, self.left_subject, self.right_subject, 4)
          return sentence
       else:
         pass




def get_rel(self):
  if not self.ref.__class__.__name__ is 'Objecttype':
    pass
  else:
    sen = []
    sentence = []
    lr = Relation.objects.filter(left_subject = self.id)
    rr = Relation.objects.filter(right_subject = self.id)
    
       
    if lr:
      """List which stores each right subject"""
      lst = get_list_relation(self, 0)
      #print "LR",lst
      for k,v in lst.iteritems():      
          rel = Relationtype.objects.filter(title = k)
          val = v   
          for rt in rel:  
             sen = get_CNL_sentence_RT(rt, self, val, 0)
             #print "sen----lr",sen
             sentence.extend(sen)
      #print "sentence lr",sentence
          
    if rr:
       """List which stores each left subject"""
       lst = get_list_relation(self, 1)
       #print "RR",lst
       for k,v in lst.iteritems():      
          rel = Relationtype.objects.filter(inverse = k)
          val = v 
          #print "rel ",rel
          #print "v ",v  
          for rt in rel:  
             sen = get_CNL_sentence_RT(rt, val, self, 1)
             #print sen,"sen"
             sentence.extend(sen)     
    return sentence



def get_RT_subjecttype(self,lst,rst):
   """Returns CNL sentence of left & right subject type of RT"""
   if self.ref.__class__.__name__ is 'Relationtype':
       left_subtype = lst
       right_subtype = rst
       st = []
       ce = "Its left_subjecttype is "+str(left_subtype)+"."
       c = ce.capitalize()
       st.append(c)
        
       de = "Its right_subjecttype is "+str(right_subtype)+"."
       d = de.capitalize()
       st.append(d)
       return st
   else:
       pass