def make(stories, weights):
weighted_tokens = []
indices = [weight[0] for weight in weights]
w = 0.0
c = ""
for story in stories:
if story.has_ends:
parts = ['role', 'means', 'ends']
else:
parts = ['role', 'means']
for part in parts:
for token in eval('story.' + str(part) + '.text'):
c = get_case(token)
if c in indices:
for weight in weights:
if weight[0] == c:
w = weight[1]
break
else:
w = 0.0
weighted_tokens.append(WeightedToken(token, w))
return weighted_tokens
def get_lowest_threshold(self, relationship):
wt = self.get_weighted_tokens(relationship)
lt = 1000.0
if wt:
lt = wt[0].weight
for w in wt:
if str.lower(get_case(w)) != self.sysname and w.weight < lt: # Exclude system name object from filter
lt = w.weight
return lt
def make_patterns(self, user_stories, threshold):
pi = PatternIdentifier(self.weighted_tokens)
self.sysname = str.lower(get_case(user_stories[0].system.main))
for story in user_stories:
pi.identify(story)
relationships = self.apply_threshold(pi.relationships, threshold)
self.create(relationships, user_stories, threshold, pi.roles)
return self.onto
def create(self, relationships, stories, threshold, roles):
used = []
for r in relationships:
pre = get_case(r[1])
post = get_case(r[3])
if r[2] == Pattern.parent:
self.onto.get_class_by_name(r[0], pre, post)
self.prolog.new_relationship(r[0], pre, 'isa', post)
if r[2] != Pattern.parent:
rel = get_case(r[4])
if r[2] == Pattern.subj_dobj or r[2] == Pattern.compound_has:
self.onto.get_class_by_name(r[0], pre)
self.onto.get_class_by_name(r[0], post)
self.prolog.new_relationship(r[0], pre, rel, post)
if r[2] == Pattern.subj_dobj:
self.make_can_relationship(r[0], pre, rel, post)
else:
self.make_has_relationship(r[0], pre, rel, post)
self.prolog.get_class_by_name(r[0], pre)
self.prolog.get_class_by_name(r[0], post)
used.append(pre)
used.append(post)
for wo in self.weighted_tokens:
if wo.weight >= threshold:
in_stories = self.find_story(wo, stories)
for in_story in in_stories:
self.onto.get_class_by_name(in_story, wo.case)
for r in roles:
self.onto.get_class_by_name(r[0], get_case(r[1]), '', True)
class Constructor:
def __init__(self, nlp, user_stories, matrix):
self.nlp = nlp
self.user_stories = user_stories
self.weights = matrix['sum'].reset_index().values.tolist()
def make(self, ontname, threshold, link):
weighted_tokens = WeightAttacher.make(self.user_stories, self.weights)
self.onto = Ontology(ontname, self.user_stories)
self.prolog = Ontology(ontname, self.user_stories)
pf = PatternFactory(self.onto, self.prolog, weighted_tokens)
self.onto = pf.make_patterns(self.user_stories, threshold)
self.prolog = pf.prolog
if link:
self.link_to_story(self.onto.classes, self.user_stories)
g = Generator(self.onto.classes, self.onto.relationships)
g_prolog = Generator(self.prolog.classes, self.prolog.relationships, False)
per_role_out = []
per_role_onto = self.get_per_role(self.user_stories, link)
for p in per_role_onto:
per_role_out.append([p[0].replace('/', '_'), p[1].prt(self.onto)])
return g.prt(self.onto), g_prolog.prt(self.prolog), self.onto, self.prolog, per_role_out
def link_to_story(self, classes, stories):
used_stories = []
for cl in classes:
for story in cl.stories:
if story >= 0:
s = self.get_story(int(story), stories)
parts = self.get_parts(cl.name, s)
# for part in part_name:
# n = s.txtnr() + part
# self.onto.get_class_by_name(-1, n, s.txtnr())
# self.onto.new_relationship(-1, cl.name, cl.name + 'OccursIn' + n, n)
self.onto.new_relationship(-1, cl.name, cl.name + 'OccursIn' + s.txtnr(), s.txtnr())
for part in parts:
self.prolog.new_relationship(-1, cl.name, part, s.txtnr())
used_stories.append(s.txtnr())
for story in used_stories:
self.onto.get_class_by_name(-1, story, 'UserStory')
def get_per_role(self, stories, link):
roles_link = []
roles = []
stories_per_role = []
per_role_ontos = []
# Get a list of roles and a list where the stories are linked to their roles
for story in self.user_stories:
roles_link.append([story.role.t, story.number])
if str.lower(story.role.t) not in [str.lower(s) for s in roles]:
roles.append(story.role.t)
# Get a list of stories per role and get the generator object for these stories
for role in roles:
stories_per_role = []
for link in roles_link:
if str.lower(role) == str.lower(link[0]):
stories_per_role.append(link[1])
per_role_ontos.append([role, self.get_generator(role, stories_per_role, link)])
return per_role_ontos
def get_generator(self, role, spr, link):
role_classes = []
role_relationships = []
cl_names = []
# Get classes
for cl in self.onto.classes:
for story in cl.stories:
if story >= 0 and story in spr and cl.name not in cl_names:
role_classes.append(cl)
cl_names.append(cl.name)
if cl.parent != '':
for cp in self.onto.classes:
if cp.name == cl.parent:
role_classes.append(cp)
# Get the general classes
if cl.stories[0] == -1:
if cl.name == 'FunctionalRole' or cl.name == 'Person':
role_classes.append(cl)
story_classes = []
# Get all relationships belonging to these classes
for rel in self.onto.relationships:
for story in rel.stories:
if rel.domain in cl_names and rel.range in cl_names and story in spr:
role_relationships.append(rel)
# If 'link' add these classes too
if link:
for story in spr:
if rel.domain in cl_names and rel.range == 'US' + str(story):
role_relationships.append(rel)
story_classes.append(rel.range)
# Retrieve all classes for the relationships created in link
if link:
for cl in self.onto.classes:
for c in story_classes:
if cl.name == c:
role_classes.append(cl)
if cl.name == 'UserStory':
role_classes.append(cl)
return Generator(role_classes, role_relationships)
def get_story(self, nr, stories):
for story in stories:
if nr == story.number:
return story
return False
def get_parts(self, class_name, story):
case = class_name.split()
means_compounds = []
means_compounds.append(story.means.main_object.compound)
ends_compounds = flatten(story.ends.compounds)
if story.means.free_form:
if len(story.means.compounds) > 0:
means_compounds.extend(flatten(story.means.compounds))
role = []
means = []
ends = []
rme = []
for token in story.data:
if token in story.role.text:
if len(case) != 1:
role.append(get_case(token))
elif token not in story.role.functional_role.compound:
role.append(get_case(token))
if token in story.means.text:
if len(case) != 1:
means.append(get_case(token))
elif token not in means_compounds:
means.append(get_case(token))
def find_story(self, w_token, stories):
nrs = []
for story in stories:
if w_token.case in [get_case(t) for t in story.data]:
nrs.append(story.number)
return nrs
for token in story.data:
if token in story.role.text:
if len(case) != 1:
role.append(get_case(token))
elif token not in story.role.functional_role.compound:
role.append(get_case(token))
if token in story.means.text:
if len(case) != 1:
means.append(get_case(token))
elif token not in means_compounds:
means.append(get_case(token))
if story.has_ends:
if token in story.ends.text:
if len(case) != 1:
ends.append(get_case(token))
elif token not in ends_compounds:
ends.append(get_case(token))
if is_sublist(case, role):
rme.append('Role')
if is_sublist(case, means):
rme.append('Means')
if is_sublist(case, ends):
rme.append('Ends')
return rme
