path: root/objectapp/cnlgb.py

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

def get_cnlgb_list(self):	
	z = []
	k = get_lex_sentence(self)
	if not k:
		pass
	else:
		z.extend(k)
        l = get_lex_sentence_optional(self)
	if not l:
		pass
	else:
		z.extend(l)
	m = get_CNL_dependency(self)
	if not m:
		pass
	else:
		z.extend(m)
	n = membership_sentence(self)
	if not n:
		pass
	else:
		z.extend(n)
        o = get_attr_sentence(self)
	if not o:
		pass
	else:
		z.extend(o)
        rel = get_rel(self)
        if not rel:
             pass
        else:
             z.extend(rel)
	return z

def advanced_cnlgb(self):
	zz=[]
	p = get_CNL_sentence_authors(self)
	if not p:
		pass
	else:
		zz.extend(p)
        """Generates CNL sentence for RT/R"""
        rt = get_RT_sentence(self)
        if not rt:
           pass
        else:
           zz.extend(rt)
	return zz


def get_lex_sentence(self): 
    if not self.ref.__class__.__name__ is 'Gbobject':
        pass
    else:      
      cns=self.get_nbh
      d=[]
      for k in cns:
          if k=='title':
            title = str(cns['title'])
       	    title_slug = slugify(title)
            if not cns[k]:
                     pass
            else:     
                     g=str(title_slug)+" is a proper-noun."
                     d.append(g.capitalize())
      return d


def get_lex_sentence_optional(self):   
    if not self.ref.__class__.__name__ is 'Gbobject':
        pass
    else: 
      cns=self.get_nbh
      title = str(cns['title'])
      title_slug = slugify(title)
      d=[]
      for k in cns:
        if k =='altnames':
            alt_name = str(cns['altnames'])
            alt_slug = slugify(alt_name)
            if not cns[k]:
                     pass
            else:             
                     i=str(cns[k])+" is an alternate name for "+str(title_slug)+"."
                     d.append(i.capitalize())

        elif k == 'plural':
            if not cns[k]:
                     pass
            else:  
                     pl = str(cns[k])
                     pl_slug = slugify(pl)           
                     m = str(pl_slug)+" is a plural of "+str(title_slug)+"."
                     d.append(m.capitalize())
        return d


      
def get_CNL_sentence_authors(self):
    if not self.ref.__class__.__name__ is 'Gbobject':
        pass
    else:   
      title = self.title
      title_slug = slugify(title)
      d=[]
      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 "+str(title_slug).title()+"."
                       d.append(e)
                                         
                   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 "+str(title_slug).title()+"."                       
                       d.append(e)
                       
      return d


def get_CNL_dependency(self):    
    if not self.ref.__class__.__name__ is 'Gbobject':  
      pass
    else:    
      title = self.title
      title_slug = slugify(title)
      d=[]                          
      if self.prior_nodes.all():
                   p_n_a = [] 
                   p_n_a = self.prior_nodes.all()
                   len_pna=len(p_n_a)                   
                   if len_pna == 1:
                     for each in p_n_a:                     
                       pn=slugify(each)                                       
                       h=str(pn).title()+" is a prior_node for "+str(title_slug).title()+"."+str(title_slug).title()+" depends upon "+str(pn).title()+"."
                       d.append(h) 
                   else:                       
                       sen = dependency_plural(p_n_a)
                       h = str(sen)+". It is the prior_node and required for the meaning of "+str(title_slug).title()+"." 
                       d.append(h)
      
      if self.posterior_nodes.all():                
                   p_n_a = []
                   p_n_a = self.posterior_nodes.all() 
                   len_pna=len(p_n_a)                   
                   if len_pna == 1:
                     for each in p_n_a:                     
                       pn = slugify(each)                                         
                       p = str(pn).title()+" is a posterior_node for "+str(title_slug).title()+"."+str(title_slug).title()+" is required for the meaning of "+str(pn).title()+"."
                       d.append(p) 
                   else:                      
		       sen = dependency_plural(p_n_a)
                       p = str(sen)+". It is the posterior_node and depends on the meaning of "+str(title_slug).title()+"."
                       d.append(p)
      return d

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


def membership_sentence(self):
    """Returns CNL sentences for membership"""
    if not self.ref.__class__.__name__ is 'Gbobject':
        pass
    else:       
      cns=self.get_nbh
      title = str(cns['title'])
      title_slug = slugify(title)
      d=[]
      for k in cns:
        if self.ref.__class__.__name__ is 'Gbobject':
	  if k=='member_of':
                 if not cns[k]:
                     pass
                 else:
                   cmm = []
                   cmm = self.objecttypes.all()
 	           len_cmm=len(cmm)                   
                   if len_cmm == 1:
                     for each in cmm:                     
                       cm=slugify(each)                                         
                       j=str(title_slug)+" is a member of a "+str(cm)+"."
                       d.append(j.capitalize())
                                         
                   else:
                       #print "len not 1"
                       y=[]
                       for each in self.objecttypes.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 a "+str(e_i)                   

                       j= str(title_slug)+" is a member of a "+sen+"."                 
                       d.append(j.capitalize())
                   
      return d


#Returns attributes for the given Gbobject
def get_attr_sentence(self):
  if not self.ref.__class__.__name__ is 'Gbobject':
        pass
  else: 
     at = Gbobject.get_attributes(self)
     if at:
       a = []
       title = self.title
       for k,v in at.iteritems():
             attr = k
             for each in v:
                  value = each
       sen = "The "+str(attr)+" of "+str(title)+" is "+str(value)+"."
       a.append(sen)
       return a


def get_list_relation(self, lr):
      """Returns the list of relations"""
      lst = []
      gbr = self.get_relations1
      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


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
         #Flag variable that checks if plural-left,right
         plural_l = 0
         plural_r = 0
         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)
            if len(ll) == 1:
                   for e in ll: 
                       left_subtype = e
            else: 
                   """Since left-ST is plural, flag value assigned 1 """
                   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"""
                 if lst.ref.__class__.__name__ is 'Gbobject':  
                     left_subtype = lst
                 else:
                     left_subtype = "a "+str(lst) 
         
         if isinstance(rlist,list):
            """If rlist is a list"""
            rl = []
            #print "Is a list"
            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                   
            else:  
                   """Since right-ST is plural, flag value assigned 1 """
                   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) 
                       
         #Core sentence - title       
         
         rel = rel_CNL(self, left_subtype, right_subtype, plural_l)
         core_t.extend(rel)               
        
         rlex = rel_lex_sentence(self)
         adv.extend(rlex)        
 
         app_NT = get_app_NT(self)
         adv.extend(app_NT)
         
         st = get_RT_subjecttype(self, left_subtype, right_subtype)
         adv.extend(st)
    
         #Is symmetrical
         if is_symmetrical:
            symm = is_symmetrical_RT(self, left_subtype, right_subtype, plural_r)
            core_i.extend(symm)         
         else:
            asymm = is_asymmetrical_RT(self, left_subtype, right_subtype, plural_r)
            core_i.extend(asymm)            
            #Is reflexive 
         if not is_reflexive:
             pass
         else:
           if detail_level == 1 or plural_l == 1:
                 st = right_subtype
           else:
                 st = left_subtype
           is_refl = is_reflexive_sentence(self, st)        
           reflexive.extend(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



#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( "/home/user/gnowsys-studio/demo/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



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)
   return rel  
         
         
def is_reflexive_sentence(self, st):
      """Generates reflexive sentence"""
      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 (type_lst == 'Gbobject' and type_rst == 'Gbobject'):
          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)
          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)          
      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 in detail
       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 in detail
       elif self.ref.__class__.__name__ is 'Relation':
          sentence = get_CNL_sentence_RT(self.relationtype, self.left_subject, self.right_subject, 4)
          return sentence




#Get relations for the Gbobject:Singular, plural
def get_rel(self):
    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)
      
      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)
             sentence.extend(sen)
          
    if rr:
       """List which stores each left subject"""
       lst = get_list_relation(self, 1)
      
       for k,v in lst.iteritems():      
          rel = Relationtype.objects.filter(inverse = k)
          val = v   
          for rt in rel:  
             sen = get_CNL_sentence_RT(rt, val, self,1)
             sentence.extend(sen)     
    return sentence



def get_RT_subjecttype(self, left_subtype, right_subtype):
   """Returns CNL sentence of left & right subject type of RT"""
   if self.ref.__class__.__name__ is 'Relationtype':
       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