lkrsnik
/
STARK
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Refactoring original code + partialy added node_order=yes

Browse Source
master
Luka 5 years ago
parent a614da9766
commit 2b5478483a
2 changed files with 174 additions and 213 deletions
Show Stats Download Patch File Download Diff File

263
Tree.py
Unescape View File

@ -7,9 +7,9 @@ from Value import Value
class Tree(object):
def __init__(self, form, lemma, upos, xpos, deprel, feats, form_dict, lemma_dict, upos_dict, xpos_dict, deprel_dict, feats_dict, head):
if not hasattr(self, 'feats'):
self.feats = {}
def __init__(self, form, lemma, upos, xpos, deprel, feats, form_dict, lemma_dict, upos_dict, xpos_dict, deprel_dict, feats_dict, feats_complete_dict, head):
# if not hasattr(self, 'feats'):
# self.feats = {}
# form_unicode = str(form).encode("utf-8")
if form not in form_dict:
@ -27,40 +27,39 @@ class Tree(object):
if deprel not in deprel_dict:
deprel_dict[deprel] = Value(deprel)
self.deprel = deprel_dict[deprel]
for feat in feats.keys():
if next(iter(feats[feat])) not in feats_dict[feat]:
feats_dict[feat][next(iter(feats[feat]))] = Value(next(iter(feats[feat])))
if not feat in self.feats:
self.feats[feat] = {}
self.feats[feat][next(iter(feats[feat]))] = feats_dict[feat][next(iter(feats[feat]))]
if feats not in feats_complete_dict:
feats_complete_dict[feats] = Value(feats)
self.feats_complete = feats_complete_dict[feats]
# for feat in feats.keys():
# if next(iter(feats[feat])) not in feats_dict[feat]:
# feats_dict[feat][next(iter(feats[feat]))] = Value(next(iter(feats[feat])))
# if not feat in self.feats:
# self.feats[feat] = {}
# self.feats[feat][next(iter(feats[feat]))] = feats_dict[feat][next(iter(feats[feat]))]
# self.position = position
self.parent = head
self.l_children = []
self.r_children = []
self.children = []
self.children_split = -1
self.index = 0
def add_l_child(self, child):
child.index = len(self.l_children)
self.l_children.append(child)
def add_r_child(self, child):
child.index = len(self.l_children) + len(self.r_children)
self.r_children.append(child)
def add_child(self, child):
child.index = len(self.children)
self.children.append(child)
def set_parent(self, parent):
self.parent = parent
def fits_static_requirements_feats(self, query_tree):
if 'feats' not in query_tree:
return True
for feat in query_tree['feats'].keys():
if feat not in self.feats or query_tree['feats'][feat] != next(iter(self.feats[feat].values())).get_value():
return False
return True
# def fits_static_requirements_feats(self, query_tree):
# if 'feats' not in query_tree:
# return True
#
# for feat in query_tree['feats'].keys():
# if feat not in self.feats or query_tree['feats'][feat] != next(iter(self.feats[feat].values())).get_value():
# return False
#
# return True
def fits_static_requirements(self, query_tree):
@ -69,7 +68,8 @@ class Tree(object):
('upos' not in query_tree or query_tree['upos'] == self.upos.get_value()) and \
('xpos' not in query_tree or query_tree['xpos'] == self.xpos.get_value()) and \
('deprel' not in query_tree or query_tree['deprel'] == self.deprel.get_value()) and \
self.fits_static_requirements_feats(query_tree)
('feats' not in query_tree or query_tree['feats'] == self.feats_complete.get_value())
# self.fits_static_requirements_feats(query_tree)
def generate_children_queries(self, all_query_indices, children):
partial_results = {}
@ -161,7 +161,7 @@ class Tree(object):
return partial_subtrees, completed_subtrees
def get_all_query_indices(self, temporary_query_trees_size, completed_subtrees_size, permanent_query_trees, all_query_indices, children, create_output_string):
def get_all_query_indices(self, temporary_query_trees_size, completed_subtrees_size, permanent_query_trees, all_query_indices, children, create_output_string, filters):
# l_partial_subtrees, l_completed_subtrees = self.get_all_query_indices(len(temporary_query_trees),
# len(permanent_query_trees),
# permanent_query_trees,
@ -188,7 +188,7 @@ class Tree(object):
for child in children:
# obtain children results
new_partial_answers_architecture, new_partial_answers, new_completed_subtrees = child.get_subtrees(permanent_query_trees, child_queries_flatten,
create_output_string)
create_output_string, filters)
assert len(new_partial_answers) == len(child_queries_flatten)
for i, new_partial_subtree in enumerate(new_partial_answers):
@ -207,7 +207,7 @@ class Tree(object):
# iterate over all answers per queries
for answer_i, answer_length in enumerate(answers_lengths):
# iterate over answers of query
partial_subtrees[answer_i], partial_subtrees_architectures[answer_i] = self.create_answers(all_new_partial_answers[i:i + answer_length], all_new_partial_answers_architecture[i:i + answer_length], answer_length, len(self.l_children))
partial_subtrees[answer_i], partial_subtrees_architectures[answer_i] = self.create_answers(all_new_partial_answers[i:i + answer_length], all_new_partial_answers_architecture[i:i + answer_length], answer_length, filters)
# while i < answers_length:
# self.create_grouped_answers()
# i += 1
@ -236,88 +236,49 @@ class Tree(object):
return partial_subtrees_architectures, partial_subtrees, completed_subtrees
def order_dependent_queries(self, active_permanent_query_trees, active_temporary_query_trees, l_partial_subtrees, l_partial_subtrees_architecture,
r_partial_subtrees, r_partial_subtrees_architecture, create_output_string, merged_partial_subtrees, merged_partial_subtrees_architecture, i, i_left, i_right):
def order_dependent_queries(self, active_permanent_query_trees, active_temporary_query_trees, partial_subtrees, partial_subtrees_architecture,
create_output_string, merged_partial_subtrees, merged_partial_subtrees_architecture, i, i_child, filters):
# string_output = ''
if i < len(active_permanent_query_trees):
if ('l_children' in active_permanent_query_trees[i] and 'r_children' in active_permanent_query_trees[i]):
merged_partial_subtree = self.create_output_left_children(l_partial_subtrees[i_left], [create_output_string(self)])
merged_partial_subtrees.append(
self.create_output_right_children(merged_partial_subtree, r_partial_subtrees[i_right]))
merged_partial_subtree_architecture = self.create_output_left_children(l_partial_subtrees_architecture[i_left], [str([self.index])])
merged_partial_subtrees_architecture.append(
self.create_output_right_children(merged_partial_subtree_architecture, l_partial_subtrees_architecture[i_right]))
# merged_partial_subtree = self.merge_results(l_partial_subtrees[i_left],
# [[create_output_string(self)]])
# merged_partial_subtrees.append(
# self.merge_results(merged_partial_subtree, r_partial_subtrees[i_right]))
# # merged_partial_subtrees.append(self.merge_results(l_partial_subtrees[i], [[create_output_string(self)]]))
i_left += 1
i_right += 1
elif 'l_children' in active_permanent_query_trees[i]:
merged_partial_subtrees.append(self.create_output_left_children(l_partial_subtrees[i_left], [create_output_string(self)]))
merged_partial_subtrees_architecture.append(self.create_output_left_children(l_partial_subtrees_architecture[i_left], [str([self.index])]))
# merged_partial_subtrees.append(
# self.merge_results(l_partial_subtrees[i_left], [[create_output_string(self)]]))
i_left += 1
elif 'r_children' in active_permanent_query_trees[i]:
merged_partial_subtrees.append(self.create_output_right_children([create_output_string(self)], r_partial_subtrees[i_right]))
merged_partial_subtrees_architecture.append(
self.create_output_right_children(r_partial_subtrees_architecture[i_left], [str([self.index])]))
# merged_partial_subtrees.append(
# self.merge_results([[create_output_string(self)]], r_partial_subtrees[i_right]))
i_right += 1
if 'children' in active_permanent_query_trees[i]:
if not filters['node_order'] or i_child < self.children_split:
merged_partial_subtrees.append(
self.create_output_left_children(partial_subtrees[i_child], [create_output_string(self)], filters))
merged_partial_subtrees_architecture.append(
self.create_output_left_children(partial_subtrees_architecture[i_child], [str([self.index])], filters))
else:
merged_partial_subtrees.append(
self.create_output_right_children([create_output_string(self)], partial_subtrees[i_child], filters))
merged_partial_subtrees_architecture.append(
self.create_output_right_children([str([self.index])], partial_subtrees_architecture[i_child], filters))
i_child += 1
else:
merged_partial_subtrees.append([create_output_string(self)])
merged_partial_subtrees_architecture.append([str([self.index])])
# merged_partial_subtrees.append([[create_output_string(self)]])
else:
if ('l_children' in active_temporary_query_trees[i - len(active_permanent_query_trees)] and 'r_children' in
active_temporary_query_trees[i - len(active_permanent_query_trees)]):
merged_partial_subtree = self.create_output_left_children(l_partial_subtrees[i_left],
[create_output_string(self)])
merged_partial_subtrees.append(
self.create_output_right_children(merged_partial_subtree, r_partial_subtrees[i_right]))
merged_partial_subtree_architecture = self.create_output_left_children(
l_partial_subtrees_architecture[i_left], [str([self.index])])
merged_partial_subtrees_architecture.append(
self.create_output_right_children(merged_partial_subtree_architecture,
l_partial_subtrees_architecture[i_right]))
# merged_partial_subtree = self.merge_results(l_partial_subtrees[i_left], [[create_output_string(self)]])
# merged_partial_subtrees.append(self.merge_results(merged_partial_subtree, r_partial_subtrees[i_right]))
# # merged_partial_subtrees.append(self.merge_results(l_partial_subtrees[i], [[create_output_string(self)]]))
i_left += 1
i_right += 1
elif 'l_children' in active_temporary_query_trees[i - len(active_permanent_query_trees)]:
merged_partial_subtrees.append(
self.create_output_left_children(l_partial_subtrees[i_left], [create_output_string(self)]))
merged_partial_subtrees_architecture.append(
self.create_output_left_children(l_partial_subtrees_architecture[i_left], [str([self.index])]))
# merged_partial_subtrees.append(
# self.merge_results(l_partial_subtrees[i_left], [[create_output_string(self)]]))
i_left += 1
elif 'r_children' in active_temporary_query_trees[i - len(active_permanent_query_trees)]:
merged_partial_subtrees.append(
self.create_output_right_children([create_output_string(self)], r_partial_subtrees[i_right]))
merged_partial_subtrees_architecture.append(
self.create_output_right_children(r_partial_subtrees_architecture[i_left], [str([self.index])]))
# merged_partial_subtrees.append(
# self.merge_results([[create_output_string(self)]], r_partial_subtrees[i_right]))
i_right += 1
if 'children' in active_temporary_query_trees[i - len(active_permanent_query_trees)]:
if not filters['node_order'] or i_child < self.children_split:
merged_partial_subtrees.append(
self.create_output_left_children(partial_subtrees[i_child], [create_output_string(self)], filters))
merged_partial_subtrees_architecture.append(
self.create_output_left_children(partial_subtrees_architecture[i_child], [str([self.index])], filters))
else:
merged_partial_subtrees.append(
self.create_output_right_children([create_output_string(self)], partial_subtrees[i_child], filters))
merged_partial_subtrees_architecture.append(
self.create_output_right_children([str([self.index])], partial_subtrees_architecture[i_child], filters))
i_child += 1
else:
merged_partial_subtrees.append([create_output_string(self)])
merged_partial_subtrees_architecture.append([str([self.index])])
# merged_partial_subtrees.append([[create_output_string(self)]])
return i_left, i_right
return i_child
def get_subtrees(self, permanent_query_trees, temporary_query_trees, create_output_string):
def get_subtrees(self, permanent_query_trees, temporary_query_trees, create_output_string, filters):
"""
:param permanent_query_trees:
@ -325,71 +286,41 @@ class Tree(object):
"""
# list of all children queries grouped by parent queries
l_all_query_indices = []
r_all_query_indices = []
all_query_indices = []
active_permanent_query_trees = []
for permanent_query_tree in permanent_query_trees:
if self.fits_static_requirements(permanent_query_tree):
if 'l_children' in permanent_query_tree and 'r_children' in permanent_query_tree:
permanent_query_tree['l_children'] += permanent_query_tree['r_children']
del(permanent_query_tree['r_children'])
elif 'r_children' in permanent_query_tree:
permanent_query_tree['l_children'] = permanent_query_tree['r_children']
del(permanent_query_tree['r_children'])
active_permanent_query_trees.append(permanent_query_tree)
if 'l_children' in permanent_query_tree:
l_all_query_indices.append((permanent_query_tree['l_children'], True))
if 'r_children' in permanent_query_tree:
r_all_query_indices.append((permanent_query_tree['l_children'], True))
if 'children' in permanent_query_tree:
all_query_indices.append((permanent_query_tree['children'], True))
# r_all_query_indices.append((permanent_query_tree['r_children'], True))
active_temporary_query_trees = []
successful_temporary_queries = []
for i, temporary_query_tree in enumerate(temporary_query_trees):
if self.fits_static_requirements(temporary_query_tree):
if 'l_children' in temporary_query_tree and 'r_children' in temporary_query_tree:
temporary_query_tree['l_children'] += temporary_query_tree['r_children']
del(temporary_query_tree['r_children'])
elif 'r_children' in temporary_query_tree:
temporary_query_tree['l_children'] = temporary_query_tree['r_children']
del(temporary_query_tree['r_children'])
active_temporary_query_trees.append(temporary_query_tree)
successful_temporary_queries.append(i)
# if 'l_children' in temporary_query_tree and 'r_children' in temporary_query_tree:
if 'l_children' in temporary_query_tree:
l_all_query_indices.append((temporary_query_tree['l_children'], False))
if 'r_children' in temporary_query_tree:
# r_all_query_indices.append((temporary_query_tree['r_children'], False))
r_all_query_indices.append((temporary_query_tree['l_children'], False))
# l_partial_subtrees, l_completed_subtrees = self.get_all_query_indices_old(len(temporary_query_trees), len(permanent_query_trees), permanent_query_trees, l_all_query_indices, self.l_children, create_output_string)
# r_partial_subtrees, r_completed_subtrees = self.get_all_query_indices_old(len(temporary_query_trees), len(permanent_query_trees), permanent_query_trees, r_all_query_indices, self.r_children, create_output_string)
all_query_indices = l_all_query_indices + r_all_query_indices
if 'children' in temporary_query_tree:
all_query_indices.append((temporary_query_tree['children'], False))
l_partial_subtrees_architecture, l_partial_subtrees, l_completed_subtrees = self.get_all_query_indices(len(temporary_query_trees),
partial_subtrees_architecture, partial_subtrees, completed_subtrees = self.get_all_query_indices(len(temporary_query_trees),
len(permanent_query_trees),
permanent_query_trees,
all_query_indices, self.l_children + self.r_children,
create_output_string)
# r_partial_subtrees_architecture, r_partial_subtrees, r_completed_subtrees = self.get_all_query_indices(len(temporary_query_trees),
# len(permanent_query_trees),
# permanent_query_trees,
# r_all_query_indices, self.r_children,
# create_output_string)
r_partial_subtrees_architecture, r_partial_subtrees, r_completed_subtrees = [], [], []
all_query_indices, self.children,
create_output_string, filters)
merged_partial_subtrees = []
merged_partial_subtrees_architecture = []
i = 0
i_left = 0
i_right = 0
i_child = 0
# go over all permanent and temporary query trees
while i < len(active_permanent_query_trees) + len(active_temporary_query_trees):
# permanent query trees always have left and right child
i_left, i_right = self.order_dependent_queries(active_permanent_query_trees, active_temporary_query_trees, l_partial_subtrees, l_partial_subtrees_architecture,
r_partial_subtrees, r_partial_subtrees_architecture, create_output_string, merged_partial_subtrees, merged_partial_subtrees_architecture, i, i_left, i_right)
i_child = self.order_dependent_queries(active_permanent_query_trees, active_temporary_query_trees, partial_subtrees, partial_subtrees_architecture,
create_output_string, merged_partial_subtrees, merged_partial_subtrees_architecture, i, i_child, filters)
# if i < len(active_permanent_query_trees):
# if ('l_children' in active_permanent_query_trees[i] and 'r_children' in active_permanent_query_trees[i]):
# merged_partial_subtree = self.merge_results(l_partial_subtrees[i_left],
@ -432,14 +363,14 @@ class Tree(object):
# # merged_partial_subtrees.append(self.merge_results(l_partial_subtrees[i], [[create_output_string(self)]]))
i += 1
completed_subtrees = l_completed_subtrees
# for i in range(len(permanent_query_trees)):
# for i in range(max(len(completed_subtrees), len(r_completed_subtrees), len(active_permanent_query_trees))):
for i in range(len(active_permanent_query_trees)):
# erase first and last braclets when adding new query result
add_subtree = [subtree[1:-1] for subtree in merged_partial_subtrees[i]]
# if 0 < len(active_permanent_query_trees):
completed_subtrees[i].extend(merged_partial_subtrees[i])
for i in range(len(r_completed_subtrees)):
completed_subtrees[i].extend(r_completed_subtrees[i])
completed_subtrees[i].extend(add_subtree)
# completed_subtrees[i].extend(merged_partial_subtrees[i])
# answers to valid queries
subtrees_architecture = [[] for i in range(len(temporary_query_trees))]
@ -480,38 +411,50 @@ class Tree(object):
return merged_results, merged_indices
@staticmethod
def create_output_left_children(left_children, new_results):
def create_output_left_children(left_children, new_results, filters):
merged_results = []
for child in left_children:
for new_result in new_results:
res = ''
if type(child) == str:
res += '(' + child + ') < '
# res += '(' + child + ') < '
res += child + ' < '
else:
for el in sorted(child):
res += '(' + el + ') < '
merged_results.append(res + new_result)
if filters['node_order']:
new_child = child
else:
new_child = sorted(child)
for el in new_child:
# res += '(' + el + ') < '
res += el + ' < '
merged_results.append('(' + res + new_result + ')')
return merged_results
@staticmethod
def create_output_right_children(new_results, right_children):
def create_output_right_children(new_results, right_children, filters):
merged_results = []
for child in right_children:
for new_result in new_results:
res = ''
if type(child) == str:
res += ' > (' + child + ')'
res += ' > ' + child
# res += ' > (' + child + ')'
else:
for el in sorted(child):
res += ' > (' + el + ')'
merged_results.append(new_result + res)
if filters['node_order']:
new_child = child
else:
new_child = sorted(child)
for el in new_child:
res += ' > ' + el
# res += ' > (' + el + ')'
merged_results.append('(' + new_result + res + ')')
# merged_results.append(new_result + ' > (' + child + ')')
return merged_results
@staticmethod
def create_answers(separated_answers, separated_answers_architecture, answer_length, l_children_len):
def create_answers(separated_answers, separated_answers_architecture, answer_length, filters):
# TODO
node_order = False
# node_order = False
partly_built_trees = [[None] * answer_length]
partly_built_trees_architecture = [[None] * answer_length]
partly_built_trees_architecture_indices = [[None] * answer_length]
@ -580,9 +523,9 @@ class Tree(object):
if is_unique:
unique_trees_architecture.append(new_tree_architecture)
if not node_order:
l_ordered_built_trees_architecture.append(new_tree_architecture)
l_ordered_built_trees.append(new_tree)
# if not filters['node_order']:
l_ordered_built_trees_architecture.append(new_tree_architecture)
l_ordered_built_trees.append(new_tree)
# TODO NODE ORDER = FALSE
# else:
#

124
dependency-parsetree.py
Unescape View File

@ -10,21 +10,22 @@ import pyconll
from Tree import Tree, create_output_string_form, create_output_string_deprel, create_output_string_lemma, create_output_string_upos, create_output_string_xpos
feats_list = [
# lexical features
'PronType', 'NumType', 'Poss', 'Reflex', 'Foreign', 'Abbr',
# Inflectional features (nominal)
'Gender', 'Animacy', 'NounClass', 'Number', 'Case', 'Definite', 'Degree',
# Inflectional features (verbal)
'VerbForm', 'Mood', 'Tense', 'Aspect', 'Voice', 'Evident', 'Polarity', 'Person', 'Polite', 'Clusivity',
# Other
'Variant', 'Number[psor]', 'Gender[psor]', 'NumForm'
]
feats_dict = {key: {} for key in feats_list}
# for separate searches of feats
# feats_list = [
# # lexical features
# 'PronType', 'NumType', 'Poss', 'Reflex', 'Foreign', 'Abbr',
#
# # Inflectional features (nominal)
# 'Gender', 'Animacy', 'NounClass', 'Number', 'Case', 'Definite', 'Degree',
#
# # Inflectional features (verbal)
# 'VerbForm', 'Mood', 'Tense', 'Aspect', 'Voice', 'Evident', 'Polarity', 'Person', 'Polite', 'Clusivity',
#
# # Other
# 'Variant', 'Number[psor]', 'Gender[psor]', 'NumForm'
# ]
#
# feats_dict = {key: {} for key in feats_list}
def decode_query(orig_query, dependency_type):
@ -59,10 +60,13 @@ def decode_query(orig_query, dependency_type):
elif orig_query_split[0] == 'form':
decoded_query['form'] = orig_query_split[1]
return decoded_query
elif orig_query_split[0] in feats_list:
decoded_query['feats'] = {}
decoded_query['feats'][orig_query_split[0]] = orig_query_split[1]
elif orig_query_split[0] == 'feats':
decoded_query['feats'] = orig_query_split[1]
return decoded_query
# elif orig_query_split[0] in feats_list:
# decoded_query['feats'] = {}
# decoded_query['feats'][orig_query_split[0]] = orig_query_split[1]
# return decoded_query
elif not new_query:
raise Exception('Not supported yet!')
elif not new_query:
@ -88,20 +92,17 @@ def decode_query(orig_query, dependency_type):
except ValueError:
root_index = len(priority_actions)
l_children = []
r_children = []
children = []
root = None
for i, node_action in enumerate(node_actions):
if i < root_index:
l_children.append(decode_query(node_action, priority_actions[i][1:]))
children.append(decode_query(node_action, priority_actions[i][1:]))
elif i > root_index:
r_children.append(decode_query(node_action, priority_actions[i - 1][1:]))
children.append(decode_query(node_action, priority_actions[i - 1][1:]))
else:
root = decode_query(node_action, dependency_type)
if l_children:
root["l_children"] = l_children
if r_children:
root["r_children"] = r_children
if children:
root["children"] = children
return root
@ -116,7 +117,7 @@ def create_trees(config):
train = pyconll.load_from_file(input_path)
form_dict, lemma_dict, upos_dict, xpos_dict, deprel_dict = {}, {}, {}, {}, {}
form_dict, lemma_dict, upos_dict, xpos_dict, deprel_dict, feats_complete_dict = {}, {}, {}, {}, {}, {}
all_trees = []
@ -125,8 +126,14 @@ def create_trees(config):
root_id = None
token_nodes = []
for token in sentence:
node = Tree(token.form, token.lemma, token.upos, token.xpos, token.deprel, token.feats, form_dict,
lemma_dict, upos_dict, xpos_dict, deprel_dict, feats_dict, token.head)
# token_feats = ''
# for k, v in token.feats.items():
# token_feats += k + next(iter(v)) + '|'
# token_feats = token_feats[:-1]
# TODO check if 5th place is always there for feats
token_feats = token._fields[5]
node = Tree(token.form, token.lemma, token.upos, token.xpos, token.deprel, token_feats, form_dict,
lemma_dict, upos_dict, xpos_dict, deprel_dict, None, feats_complete_dict, token.head)
token_nodes.append(node)
if token.deprel == 'root':
root = node
@ -137,14 +144,21 @@ def create_trees(config):
token.set_parent(None)
else:
parent_id = int(token.parent) - 1
if token_id < parent_id:
token_nodes[parent_id].add_l_child(token)
elif token_id > parent_id:
token_nodes[parent_id].add_r_child(token)
else:
raise Exception('Root element should not be here!')
# if token_id < parent_id:
# token_nodes[parent_id].add_l_child(token)
# elif token_id > parent_id:
# token_nodes[parent_id].add_r_child(token)
# else:
# raise Exception('Root element should not be here!')
if token_nodes[parent_id].children_split == -1 and token_id > parent_id:
token_nodes[parent_id].children_split = len(token_nodes[parent_id].children)
token_nodes[parent_id].add_child(token)
token.set_parent(token_nodes[parent_id])
for token in token_nodes:
if token.children_split == -1:
token.children_split = len(token.children)
if root == None:
raise Exception('No root element in sentence!')
all_trees.append(root)
@ -179,9 +193,11 @@ def printable_answers(query):
if len(node_actions) > 1:
res = []
for node_action in node_actions[:-1]:
res.extend(printable_answers(node_action[1:-1]))
res.extend([node_actions[-1]])
# for node_action in node_actions[:-1]:
# res.extend(printable_answers(node_action[1:-1]))
# res.extend([node_actions[-1]])
for node_action in node_actions:
res.extend(printable_answers(node_action))
return res
else:
return [query]
@ -205,18 +221,18 @@ def main():
ngrams = 0
if config.getint('settings', 'ngrams') == 2:
ngrams = 2
query_tree = [{"l_children": [{}]}]
query_tree = [{"children": [{}]}]
elif config.getint('settings', 'ngrams') == 3:
ngrams = 3
query_tree = [{"l_children": [{}, {}]}, {"l_children": [{"l_children": [{}]}]}]
query_tree = [{"children": [{}, {}]}, {"children": [{"children": [{}]}]}]
elif config.getint('settings', 'ngrams') == 4:
ngrams = 4
query_tree = [{"l_children": [{}, {}, {}]}, {"l_children": [{"l_children": [{}, {}]}]}, {"l_children": [{"l_children": [{}]}, {}]}, {"l_children": [{"l_children": [{"l_children": [{}]}]}]}]
query_tree = [{"children": [{}, {}, {}]}, {"children": [{"children": [{}, {}]}]}, {"children": [{"children": [{}]}, {}]}, {"children": [{"children": [{"children": [{}]}]}]}]
elif config.getint('settings', 'ngrams') == 5:
ngrams = 5
query_tree = [{"l_children": [{}, {}, {}, {}]}, {"l_children": [{"l_children": [{}]}, {}, {}]}, {"l_children": [{"l_children": [{}, {}]}, {}]}, {"l_children": [{"l_children": [{}]}, {"l_children": [{}]}]},
{"l_children": [{"l_children": [{"l_children": [{}]}]}, {}]}, {"l_children": [{"l_children": [{"l_children": [{}]}, {}]}]}, {"l_children": [{"l_children": [{"l_children": [{}, {}]}]}]},
{"l_children": [{"l_children": [{"l_children": [{"l_children": [{}]}]}]}]}]
query_tree = [{"children": [{}, {}, {}, {}]}, {"children": [{"children": [{}]}, {}, {}]}, {"children": [{"children": [{}, {}]}, {}]}, {"children": [{"children": [{}]}, {"children": [{}]}]},
{"children": [{"children": [{"children": [{}]}]}, {}]}, {"children": [{"children": [{"children": [{}]}, {}]}]}, {"children": [{"children": [{"children": [{}, {}]}]}]},
{"children": [{"children": [{"children": [{"children": [{}]}]}]}]}]
else:
query_tree = [decode_query('(' + config.get('settings', 'query') + ')', '')]
# order_independent_queries(query_tree)
@ -238,14 +254,16 @@ def main():
create_output_string_funct = create_output_string_form
result_dict = {}
filters = {}
filters['node_order'] = config.getboolean('settings', 'node_order')
# for tree in all_trees[2:]:
for tree in all_trees[2:]:
# for tree in all_trees[1205:]:
for tree in all_trees:
# for tree in all_trees:
# original
# r_children = tree.r_children[:1] + tree.r_children[3:4]
# tree.r_children = tree.r_children[:1] + tree.r_children[2:4]
_, _, subtrees = tree.get_subtrees(query_tree, [], create_output_string_funct)
_, _, subtrees = tree.get_subtrees(query_tree, [], create_output_string_funct, filters)
for query_results in subtrees:
for result in query_results:
# if ngrams:
@ -258,13 +276,13 @@ def main():
result_dict[r] = 1
# test 1 layer queries
# # tree.r_children = []
# # tree.l_children[1].l_children = []
# # query = [{'l_children': [{}]}, {'r_children': [{}]}]
# # query = [{"l_children": [{}, {}]}, {"l_children": [{}]}, {"l_children": [{}, {}, {}]}]
# query = [{"l_children": [{'form': 'je'}, {}]}, {"l_children": [{'form': 'je'}]}, {"l_children": [{'form': 'je'}, {}, {}]}]
# # query = [{'q1':'', "l_children": [{'a1':''}, {'a2':''}]}, {'q2':'', "l_children": [{'b1':''}]}, {'q3':'', "l_children": [{'c1':''}, {'c2':''}, {'c3':''}]}]
# # tree.children[1].children = []
# # query = [{'children': [{}]}, {'children': [{}]}]
# # query = [{"children": [{}, {}]}, {"children": [{}]}, {"children": [{}, {}, {}]}]
# query = [{"children": [{'form': 'je'}, {}]}, {"children": [{'form': 'je'}]}, {"children": [{'form': 'je'}, {}, {}]}]
# # query = [{'q1':'', "children": [{'a1':''}, {'a2':''}]}, {'q2':'', "children": [{'b1':''}]}, {'q3':'', "children": [{'c1':''}, {'c2':''}, {'c3':''}]}]
# _, _, subtrees = tree.get_subtrees(query, [], create_output_string_funct)
# # _, subtrees = tree.get_subtrees([{'q1':'', "l_children": [{'a1':''}, {'a2':''}], "r_children": []}, {'q2':'', "l_children": [{'b1':''}], "r_children": []}, {'q3':'', "l_children": [{'c1':''}, {'c2':''}, {'c3':''}], "r_children": []}], [])
# # _, subtrees = tree.get_subtrees([{'q1':'', "children": [{'a1':''}, {'a2':''}], "children": []}, {'q2':'', "children": [{'b1':''}], "children": []}, {'q3':'', "children": [{'c1':''}, {'c2':''}, {'c3':''}], "children": []}], [])
# print('HERE!')
# test 2 layer queries

Write Preview
Loading…
Cancel
Save