Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
tree: 3ba6b57c6d
Fetching contributors…

Cannot retrieve contributors at this time

634 lines (551 sloc) 21.411 kb
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
Jump to Line
Something went wrong with that request. Please try again.