STARK/Tree.py

import sys
from copy import copy

from Result import Result
from ResultNode import ResultNode
from ResultTree import ResultTree
from Value import Value
from generic import create_output_string_form, create_output_string_deprel, create_output_string_lemma, \
    create_output_string_upos, create_output_string_xpos, create_output_string_feats, generate_key


class Tree(object):
    def __init__(self, index, form, lemma, upos, xpos, deprel, feats, feats_detailed, form_dict, lemma_dict, upos_dict, xpos_dict, deprel_dict, feats_dict, feats_detailed_dict, head):
        if not hasattr(self, 'feats'):
            self.feats_detailed = {}

        # form_unicode = str(form).encode("utf-8")
        if form not in form_dict:
            form_dict[form] = Value(form)
        self.form = form_dict[form]
        if lemma not in lemma_dict:
            lemma_dict[lemma] = Value(lemma)
        self.lemma = lemma_dict[lemma]
        if upos not in upos_dict:
            upos_dict[upos] = Value(upos)
        self.upos = upos_dict[upos]
        if xpos not in xpos_dict:
            xpos_dict[xpos] = Value(xpos)
        self.xpos = xpos_dict[xpos]
        if deprel not in deprel_dict:
            deprel_dict[deprel] = Value(deprel)
        self.deprel = deprel_dict[deprel]
        if feats not in feats_dict:
            feats_dict[feats] = Value(feats)
        self.feats = feats_dict[feats]
        for feat in feats_detailed.keys():
            if feat not in feats_detailed_dict:
                feats_detailed_dict[feat] = {}
            if next(iter(feats_detailed[feat])) not in feats_detailed_dict[feat]:
                feats_detailed_dict[feat][next(iter(feats_detailed[feat]))] = Value(next(iter(feats_detailed[feat])))
            if not feat in self.feats_detailed:
                self.feats_detailed[feat] = {}
            self.feats_detailed[feat][next(iter(feats_detailed[feat]))] = feats_detailed_dict[feat][next(iter(feats_detailed[feat]))]
        # self.position = position

        self.parent = head
        self.children = []
        self.children_split = -1

        self.index = index

        # for caching answers to questions
        self.cache = {}

    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_detailed' not in query_tree:
            return True

        for feat in query_tree['feats_detailed'].keys():
            if feat not in self.feats_detailed or query_tree['feats_detailed'][feat] != next(iter(self.feats_detailed[feat].values())).get_value():
                return False

        return True


    def fits_permanent_requirements(self, filters):
        main_attributes = ['deprel', 'feats', 'form', 'lemma', 'upos']

        if not filters['root_whitelist']:
            return True

        for option in filters['root_whitelist']:
            filter_passed = True

            # check if attributes are valid
            for key in option.keys():
                if key not in main_attributes:
                    if key not in self.feats_detailed or option[key] != list(self.feats_detailed[key].items())[0][1].get_value():
                        filter_passed = False

            filter_passed = filter_passed and \
                            ('deprel' not in option or option['deprel'] == self.deprel.get_value()) and \
                            ('feats' not in option or option['feats'] == self.feats.get_value()) and \
                            ('form' not in option or option['form'] == self.form.get_value()) and \
                            ('lemma' not in option or option['lemma'] == self.lemma.get_value()) and \
                            ('upos' not in option or option['upos'] == self.upos.get_value())

            if filter_passed:
                return True

        return False

    def fits_temporary_requirements(self, filters):
        return not filters['label_whitelist'] or self.deprel.get_value() in filters['label_whitelist']

    def fits_static_requirements(self, query_tree, filters):
        return ('form' not in query_tree or query_tree['form'] == self.form.get_value()) and \
               ('lemma' not in query_tree or query_tree['lemma'] == self.lemma.get_value()) and \
               ('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 \
               ('feats' not in query_tree or query_tree['feats'] == self.feats.get_value()) and \
               (not filters['complete_tree_type'] or (len(self.children) == 0 and 'children' not in query_tree) or ('children' in query_tree and len(self.children) == len(query_tree['children']))) and \
               self.fits_static_requirements_feats(query_tree)

    def generate_children_queries(self, all_query_indices, children):
        partial_results = {}
        # list of pairs (index of query in group, group of query, is permanent)
        child_queries_metadata = []
        for child_index, child in enumerate(children):
            new_queries = []

            # add continuation queries to children
            for result_part_index, result_index, is_permanent in child_queries_metadata:
                if result_index in partial_results and result_part_index in partial_results[result_index] and len(partial_results[result_index][result_part_index]) > 0:
                    if len(all_query_indices[result_index][0]) > result_part_index + 1:
                        new_queries.append((result_part_index + 1, result_index, is_permanent))
                    # else:
                    #     completed_subtrees.append((child, result_index))

            child_queries_metadata = new_queries

            # add new queries to children
            for result_index, (group, is_permanent) in enumerate(all_query_indices):
                # check if node has enough children for query to be possible
                if len(children) - len(group) >= child_index:
                    child_queries_metadata.append((0, result_index, is_permanent))

            child_queries = []
            for result_part_index, result_index, _ in child_queries_metadata:
                child_queries.append(all_query_indices[result_index][0][result_part_index])

            partial_results = yield child, child_queries, child_queries_metadata
        yield None, None, None

    def add_subtrees(self, old_subtree, new_subtree):
        old_subtree.extend(new_subtree)


    # def get_results(self, partial_results_dict, result_index, result_part, outcome, last_result_part):
    #     # save results for later usage
    #
    #     # if result index already in and element 0 exists (otherwise error)
    #     if result_index in partial_results_dict and 0 in partial_results_dict[result_index]:
    #         if result_part - 1 in partial_results_dict[result_index]:
    #             if result_part in partial_results_dict[result_index]:
    #                 partial_results_dict[result_index][result_part].extend(self.merge_results(partial_results_dict[result_index][result_part - 1], outcome))
    #             else:
    #                 partial_results_dict[result_index][result_part] = self.merge_results(partial_results_dict[result_index][result_part - 1], outcome)
    #
    #         # extend one word layer with output
    #         else:
    #             partial_results_dict[result_index][0].extend(outcome)
    #     else:
    #         partial_results_dict[result_index] = {0: outcome}
    #
    #     if last_result_part - 1 in partial_results_dict[result_index]:
    #         return partial_results_dict[result_index].pop(last_result_part - 1)
    #     return []

    # def group_results(self, new_partial_subtrees, child_queries_metadata, all_query_indices, partial_results_dict, partial_subtrees):
    #     for outcome, (result_part, result_index, is_permanent) in zip(new_partial_subtrees, child_queries_metadata):
    #         if outcome:
    #             new_results = self.get_results(partial_results_dict, result_index, result_part, outcome, len(all_query_indices[result_index][0]))
    #             if new_results:
    #                 self.add_subtrees(partial_subtrees[result_index], new_results)
    #         else:
    #             if not is_permanent:
    #                 partial_subtrees[result_index].append([])

    # def get_all_query_indices_old(self, temporary_query_trees_size, completed_subtrees_size, permanent_query_trees, l_all_query_indices, children, create_output_string):
    #     partial_subtrees = [[] for i in range(completed_subtrees_size + temporary_query_trees_size)]
    #     completed_subtrees = [[] for i in range(completed_subtrees_size)]
    #
    #     # list of pairs (index of query in group, group of query)
    #     partial_results_dict = {}
    #
    #     children_queries_generator = self.generate_children_queries(l_all_query_indices, children)
    #
    #     child_index = 0
    #     child, child_queries, child_queries_metadata = next(children_queries_generator)
    #     while child:
    #         # obtain children results
    #         new_partial_subtrees, new_completed_subtrees = child.get_subtrees(permanent_query_trees, child_queries, create_output_string)
    #
    #         self.group_results(new_partial_subtrees, child_queries_metadata, l_all_query_indices,
    #                            partial_results_dict, partial_subtrees)
    #
    #         for i in range(len(new_completed_subtrees)):
    #             completed_subtrees[i].extend(new_completed_subtrees[i])
    #         child, child_queries, child_queries_metadata = children_queries_generator.send(partial_results_dict)
    #         child_index += 1
    #
    #     return partial_subtrees, completed_subtrees

    def get_all_query_indices(self, temporary_query_nb, permanent_query_nb, 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,
        #                                                                       l_all_query_indices, self.l_children,
        #                                                                       create_output_string)
        partial_answers = [[] for i in range(permanent_query_nb + temporary_query_nb)]
        partial_answers_index = [[] for i in range(permanent_query_nb + temporary_query_nb)]
        complete_answers = [[] for i in range(permanent_query_nb)]

        # list of pairs (index of query in group, group of query)
        partial_results_dict = {}

        # TODO try to erase!!!
        child_queries = [all_query_indice[0] for all_query_indice in all_query_indices]

        answers_lengths = [len(query) for query in child_queries]

        child_queries_flatten = [query_part for query in child_queries for query_part in query]

        all_new_partial_answers = [[] for query_part in child_queries_flatten]

        # if filters['caching']:
        # erase duplicate queries
        child_queries_flatten_dedup = []
        child_queries_flatten_dedup_indices = []
        for query_part in child_queries_flatten:
            try:
                index = child_queries_flatten_dedup.index(query_part)
            except ValueError:
                index = len(child_queries_flatten_dedup)
                child_queries_flatten_dedup.append(query_part)

            child_queries_flatten_dedup_indices.append(index)

        # ask children all queries/partial queries
        for child in children:
            # obtain children results
            # if filters['caching']:
            new_partial_answers_dedup, new_complete_answers = child.get_subtrees(permanent_query_trees, child_queries_flatten_dedup,
                                                                              create_output_string, filters)

            assert len(new_partial_answers_dedup) == len(child_queries_flatten_dedup)

            # duplicate results again on correct places
            for i, flattened_index in enumerate(child_queries_flatten_dedup_indices):
                all_new_partial_answers[i].append(new_partial_answers_dedup[flattened_index])

            # else:
            #     new_partial_answers_architecture, new_partial_answers, new_complete_answers = child.get_subtrees(
            #         permanent_query_trees, child_queries_flatten,
            #         create_output_string, filters)
            #
            #     assert len(new_partial_answers) == len(child_queries_flatten)
            #
            #     for i, new_partial_subtree in enumerate(new_partial_answers):
            #         all_new_partial_answers[i].append(new_partial_subtree)
            #         all_new_partial_answers_architecture[i].append(new_partial_answers_architecture[i])
            #         # if len(new_partial_answers_architecture[i]) > 1:
            #         #     print('HERE!!!')
            #         all_new_partial_answers_deprel[i].append(create_output_string_deprel(child))

            # add 6 queries from 3 split up
            # self.group_results(new_partial_subtrees, child_queries_metadata, all_query_indices,
            #                    partial_results_dict, partial_subtrees)

            for i in range(len(new_complete_answers)):
                # TODO add order rearagement (TO KEY)
                complete_answers[i].extend(new_complete_answers[i])

        # if create_output_string_form(self) == 'Dogodek':
        #     print('HERE!@@!')
        # if create_output_string_form(self) == 'vpiti':
        #     print('HERE!@@!')
        # merge answers in appropriate way
        i = 0
        # iterate over all answers per queries
        for answer_i, answer_length in enumerate(answers_lengths):
            # iterate over answers of query
            # TODO ERROR IN HERE!
            partial_answers[answer_i] = self.create_answers(all_new_partial_answers[i:i + answer_length], answer_length, filters)
            # while i < answers_length:
            #     self.create_grouped_answers()
            #     i += 1
            i += answer_length

            # merged_results = []
            # for old_result in old_results:
            #     for new_result in new_results:
            #         merged_results.append(old_result + new_result)
            # return merged_results
        # children_queries_generator = self.generate_children_queries(all_query_indices, children)
        #
        # child_index = 0
        # child, child_queries, child_queries_metadata = next(children_queries_generator)
        # while child:
        #     # obtain children results
        #     new_partial_subtrees, new_completed_subtrees = child.get_subtrees(permanent_query_trees, child_queries, create_output_string)
        #
        #     self.group_results(new_partial_subtrees, child_queries_metadata, all_query_indices,
        #                        partial_results_dict, partial_subtrees)
        #
        #     for i in range(len(new_completed_subtrees)):
        #         completed_subtrees[i].extend(new_completed_subtrees[i])
        #     child, child_queries, child_queries_metadata = children_queries_generator.send(partial_results_dict)
        #     child_index += 1

        return partial_answers, complete_answers

    def order_dependent_queries(self, active_permanent_query_trees, active_temporary_query_trees, partial_subtrees,
                                create_output_string, merged_partial_subtrees, i_query, i_answer, filters):
        # string_output = ''
        # if create_output_string_form(self) == 'vožnji':
        #     print('HERE!@@!')
        # if create_output_string_form(self) == 'začelo':
        #     print('HERE!@@!')
        node = ResultNode(self, self.index, create_output_string)

        # TEST = ResultTree(node, [], filters)
        # a = TEST.create_key()
        # if i_query < len(active_permanent_query_trees):
        #     if 'children' in active_permanent_query_trees[i_query]:
        #         merged_partial_subtrees.append(
        #             self.create_output_children(partial_subtrees[i_answer], [Result(self, self.index, create_output_string)], filters))
        #         i_answer += 1
        #     else:
        #         merged_partial_subtrees.append([Result(self, self.index, create_output_string)])
        # else:
        #     if 'children' in active_temporary_query_trees[i_query - len(active_permanent_query_trees)]:
        #         merged_partial_subtrees.append(
        #             self.create_output_children(partial_subtrees[i_answer], [Result(self, self.index, create_output_string)], filters))
        #         i_answer += 1
        #     else:
        #         merged_partial_subtrees.append([Result(self, self.index, create_output_string)])

        if i_query < len(active_permanent_query_trees):
            if 'children' in active_permanent_query_trees[i_query]:
                merged_partial_subtrees.append(
                    self.create_output_children(partial_subtrees[i_answer], [ResultTree(node, [], filters)], filters))
                i_answer += 1
            else:
                merged_partial_subtrees.append([ResultTree(node, [], filters)])
        else:
            if 'children' in active_temporary_query_trees[i_query - len(active_permanent_query_trees)]:
                merged_partial_subtrees.append(
                    self.create_output_children(partial_subtrees[i_answer], [ResultTree(node, [], filters)], filters))
                i_answer += 1
            else:
                merged_partial_subtrees.append([ResultTree(node, [], filters)])



        return i_answer

    def get_unigrams(self, create_output_strings, filters):
        unigrams = [generate_key(self, create_output_strings, print_lemma=False)[1]]
        for child in self.children:
            unigrams += child.get_unigrams(create_output_strings, filters)
        return unigrams

    def get_subtrees(self, permanent_query_trees, temporary_query_trees, create_output_string, filters):
        """

        :param permanent_query_trees:
        :param temporary_query_trees:
        """

        # if create_output_string_form(self) == 'vožnji':
        #     print('HERE!@@!')

        # list of all children queries grouped by parent queries
        all_query_indices = []

        active_permanent_query_trees = []
        for permanent_query_tree in permanent_query_trees:
            if self.fits_static_requirements(permanent_query_tree, filters) and self.fits_permanent_requirements(filters):
                active_permanent_query_trees.append(permanent_query_tree)
                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, filters) and self.fits_temporary_requirements(filters):
                # if 'l_children' in temporary_query_tree and 'r_children' in temporary_query_tree:
                active_temporary_query_trees.append(temporary_query_tree)
                successful_temporary_queries.append(i)
                if 'children' in temporary_query_tree:
                    all_query_indices.append((temporary_query_tree['children'], False))

        partial_subtrees, complete_answers = self.get_all_query_indices(len(temporary_query_trees),
                                                                                                      len(permanent_query_trees),
                                                                                                      permanent_query_trees,
                                                                                                      all_query_indices, self.children,
                                                                                                      create_output_string, filters)

        merged_partial_answers = []
        # merged_partial_answers_architecture = []
        i_question = 0
        # i_child is necessary, because some queries may be answered at the beginning and were not passed to children.
        # i_child is used to point where we are inside answers
        i_answer = 0
        # go over all permanent and temporary query trees
        while i_question < len(active_permanent_query_trees) + len(active_temporary_query_trees):
            # permanent query trees always have left and right child
            i_answer = self.order_dependent_queries(active_permanent_query_trees, active_temporary_query_trees, partial_subtrees,
                                                           create_output_string, merged_partial_answers, i_question, i_answer, filters)

            i_question += 1

        for i in range(len(active_permanent_query_trees)):
            # TODO FINALIZE RESULT
            # erase first and last braclets when adding new query result
            add_subtree = [subtree.finalize_result() for subtree in merged_partial_answers[i]]
            # if 0 < len(active_permanent_query_trees):
            complete_answers[i].extend(add_subtree)
            # completed_subtrees[i].extend(merged_partial_subtrees[i])

        # answers to valid queries
        partial_answers = [[] for i in range(len(temporary_query_trees))]
        for inside_i, outside_i in enumerate(successful_temporary_queries):
            # partial_answers_architecture[outside_i] = merged_partial_answers_architecture[len(active_permanent_query_trees) + inside_i]
            partial_answers[outside_i] = merged_partial_answers[
                len(active_permanent_query_trees) + inside_i]

        # return subtrees_architecture, subtrees, completed_subtrees
        return partial_answers, complete_answers
        # return merged_partial_subtrees_architecture[len(active_permanent_query_trees):], merged_partial_subtrees[len(active_permanent_query_trees):], completed_subtrees

    # @staticmethod
    # def merge_results(left_parts, right_parts, separator, left=True, right_part_free=False):
    #     if not left_parts:
    #         # return all right_parts
    #         return [r_p.add_separator(separator, left) for r_p in right_parts]
    #         # if left:
    #         #     return [r_p + separator for r_p in right_parts]
    #         #     # return [r_p.add_separator(separator, left) for r_p in right_parts]
    #         # else:
    #         #     return [separator + r_p for r_p in right_parts]
    #
    #     if not right_parts:
    #         return [l_p.add_separator(separator, False) for l_p in left_parts]
    #         # return [separator + l_p for l_p in left_parts]
    #     merged_results = []
    #     for left_part in left_parts:
    #         if right_part_free:
    #             for right_part in right_parts[1]:
    #                 merged_results.append((right_parts[0], left_part.merge_results(right_part, separator, left)))
    #         else:
    #             for right_part in right_parts:
    #                 merged_results.append(left_part.merge_results(right_part, separator, left))
    #             # merged_results.append(left_part.merge_results(right_part, separator))
    #             # if separator:
    #             #     if left:
    #             #         merged_results.append(left_part + right_part + separator)
    #             #     else:
    #             #         merged_results.append(left_part + separator + right_part)
    #             # else:
    #             #     merged_results.append(left_part + right_part)
    #     return merged_results

    @staticmethod
    def create_children_groups(left_parts, right_parts):
        if not left_parts:
            # return all right_parts
            return right_parts
            # if left:
            #     return [r_p + separator for r_p in right_parts]
            #     # return [r_p.add_separator(separator, left) for r_p in right_parts]
            # else:
            #     return [separator + r_p for r_p in right_parts]

        if not right_parts:
            return left_parts
            # return [separator + l_p for l_p in left_parts]
        all_children_group_possibilities = []
        for left_part in left_parts:
            for right_part in right_parts:
                new_part = copy(left_part)
                # new_part.reset_params()
                new_part.extend(right_part)
                all_children_group_possibilities.append(new_part)
                # merged_results.append(left_part.merge_results(right_part, separator))
                # if separator:
                #     if left:
                #         merged_results.append(left_part + right_part + separator)
                #     else:
                #         merged_results.append(left_part + separator + right_part)
                # else:
                #     merged_results.append(left_part + right_part)
        return all_children_group_possibilities

    @staticmethod
    def merge_answer(answer1, answer2, base_answer_i, answer_j):
        merged_results = []
        merged_indices = []
        for answer1p_i, old_result in enumerate(answer1):
            for answer2p_i, new_result in enumerate(answer2):
                if answer1p_i != answer2p_i:
                    new_indices = [answer1p_i] + [answer2p_i]
                    sorted_indices = sorted(new_indices)

                    if sorted_indices in merged_indices:
                        test = merged_indices.index(sorted(new_indices))
                        # TODO add comparison answers with different indices if equal than ignore
                    merged_results.append(old_result + new_result)
                    merged_indices.append(new_indices)
        return merged_results, merged_indices

    # def merge_results2(self, child, new_results, filters):
    #     if create_output_string_form(self) == 'začelo':
    #         print('HERE!@@!')
    #     if create_output_string_form(self) == 'Dogodek':
    #         print('HERE!@@!')
    #     if create_output_string_form(self) == 'utišal':
    #         print('HERE!@@!')
    #     if create_output_string_form(self) == 'prijel':
    #         print('HERE!@@!')
    #     if filters['node_order']:
    #         new_child = child
    #         # new_child_sorted = sorted(enumerate(child), key=lambda x: x[1][0].key)
    #     else:
    #         new_child = sorted(child, key=lambda x: x[0].key)
    #
    #     l_res = []
    #     r_res = []
    #     results = []
    #     for i_answer, answer in enumerate(new_child):
    #         if filters['node_order'] and answer[0].order[0] < self.index:
    #         # if filters['node_order'] and indices[i_child][i_answer] < self.children_split:
    #             if filters['dependency_type']:
    #                 # separator = ' <' + deprel[i_child][i_answer] + ' '
    #                 separator = ' <' + answer[0].deprel + ' '
    #             else:
    #                 separator = ' < '
    #             l_res = self.merge_results(l_res, answer, separator, left=True)
    #             # l_res += answer + separator
    #         else:
    #             if filters['dependency_type']:
    #                 separator = ' >' + answer[0].deprel + ' '
    #             else:
    #                 separator = ' > '
    #             r_res = self.merge_results(r_res, answer, separator, left=False)
    #             # r_res += separator + answer
    #
    #     # if filters['node_order']:
    #     #     r_res_sorted = []
    #     #     for i_answer, answer in new_child_sorted:
    #     #         if filters['dependency_type']:
    #     #             separator = ' >' + answer[0].deprel + ' '
    #     #         else:
    #     #             separator = ' > '
    #     #         r_res_sorted = (i_answer, self.merge_results(r_res_sorted, answer, separator, left=False))
    #     #
    #     #
    #     #     r_res_sorted_combined = self.merge_results(new_results, r_res_sorted, None, right_part_free=True)
    #     #     # print('here')
    #
    #     if l_res:
    #         l_res_combined = self.merge_results(l_res, new_results, None)
    #         if r_res:
    #             r_res_combined = self.merge_results(l_res_combined, r_res, None)
    #             # merged_results.extend(['(' + el + ')' for el in r_res_combined])
    #             result = r_res_combined
    #             # results.extend([el.put_in_bracelets() for el in r_res_combined])
    #         else:
    #             result = l_res_combined
    #             # results.extend([el.put_in_bracelets() for el in l_res_combined])
    #     elif r_res:
    #         r_res_combined = self.merge_results(new_results, r_res, None)
    #         result = r_res_combined
    #         # results.extend([el.put_in_bracelets() for el in r_res_combined])
    #     else:
    #         result = []
    #
    #
    #     results.extend([el.put_in_bracelets() for el in result])
    #
    #     return results

    # def create_merged_results(self, answers, separators, separator_switch):
    #     new_answers = []
    #     for answer_i, answer in enumerate(answers):
    #         new_answer = copy(answer[0])
    #         print(create_output_string_form(self))
    #         for answer_part_i, answer_part in enumerate(answer[1:]):
    #             new_answer.extend_answer(answer_part, separators[answer_part_i])
    #         new_answer.put_in_bracelets(inplace=True)
    #         new_answers.append(new_answer)
    #     return new_answers
    # def create_merged_results(self, new_child, new_answers, i_child, indices, deprel, filters):

    def merge_results3(self, child, new_results, filters):
        # if create_output_string_form(self) == 'Dogodek':
        #     print('HERE!@@!')
        # if create_output_string_form(self) == 'začelo':
        #     print('HERE!@@!')
        # if create_output_string_form(self) == 'utišal':
        #     print('HERE!@@!')
        # if create_output_string_form(self) == 'prijel':
        #     print('HERE!@@!')

        if filters['node_order']:
            new_child = child
            # new_child_sorted = sorted(enumerate(child), key=lambda x: x[1][0].key)
            # new_child_sorted = sorted(child, key=lambda x: x[0].get_key())
        else:
            new_child = sorted(child, key=lambda x: x[0].get_key())

        children_groups = []

        for i_answer, answer in enumerate(new_child):
            children_groups = self.create_children_groups(children_groups, [[answer_part] for answer_part in answer])
                # r_res += separator + answer

        # children_groups_sorted = []
        # for i_answer, answer in enumerate(new_child_sorted):
        #     children_groups_sorted = self.create_children_groups(children_groups_sorted, [[answer_part] for answer_part in answer])
        #
        #
        # results_sorted = {}
        # for result in new_results:
        #     for children in children_groups_sorted:
        #         new_result = copy(result)
        #         new_result.set_children(children)
        #         order = tuple(sorted(new_result.get_order()))
        #         results_sorted[order] = new_result


        results = []
        for result in new_results:
            for children in children_groups:
                new_result = copy(result)
                # if result.key is not None or result.order is not None or result.array is not None or result.order_key is not None:
                #     print('here')
                # new_result.reset_params()
                new_result.set_children(children)
                # order = tuple(sorted(new_result.get_order()))
                results.append(new_result)

        return results

    def create_output_children(self, children, new_results, filters):
        # if create_output_string_form(self) == 'Dogodek':
        #     print('HERE!@@!')
        # if create_output_string_form(self) == 'utišal':
        #     print('HERE!@@!')
        # if len(new_results) > 1:
        #     print('HERE')
        merged_results = []
        for i_child, child in enumerate(children):
            # merged_results.extend(self.merge_results2(child, new_results, filters))
            merged_results.extend(self.merge_results3(child, new_results, filters))
        return merged_results

    # @staticmethod
    def create_answers(self, separated_answers, answer_length, filters):
        partly_built_trees = [[None] * answer_length]
        partly_built_trees_architecture_indices = [[None] * answer_length]
        built_trees = []
        built_trees_architecture_indices = []

        # if create_output_string_form(self) == 'Dogodek':
        #     print('HERE!@@!')

        # iterate over children first, so that new partly built trees are added only after all results of specific
        # child are added
        for child_i in range(len(separated_answers[0])):
            new_partly_built_trees = []
            new_partly_built_trees_architecture_indices = []
            # iterate over answers parts
            for answer_part_i in range(len(separated_answers)):
                # necessary because some parts do not pass filters and are not added
                if separated_answers[answer_part_i][child_i]:
                    for tree_part_i, tree_part in enumerate(partly_built_trees):
                        if not tree_part[answer_part_i]:
                            new_tree_part = copy(tree_part)
                            new_tree_part_architecture_indices = copy(partly_built_trees_architecture_indices[tree_part_i])
                            new_tree_part[answer_part_i] = separated_answers[answer_part_i][child_i]
                            new_tree_part_architecture_indices[answer_part_i] = child_i
                            completed_tree_part = True
                            for val_i, val in enumerate(new_tree_part):
                                if not val:
                                    completed_tree_part = False
                            if completed_tree_part:
                                built_trees.append(new_tree_part)
                                built_trees_architecture_indices.append(new_tree_part_architecture_indices)
                            else:
                                new_partly_built_trees.append(new_tree_part)
                                new_partly_built_trees_architecture_indices.append(new_tree_part_architecture_indices)
                        else:
                            # pass over repetitions of same words
                            pass

            partly_built_trees.extend(new_partly_built_trees)
            partly_built_trees_architecture_indices.extend(new_partly_built_trees_architecture_indices)

        l_ordered_built_trees, unique_trees_architecture = [], []

        if built_trees:
            # sort 3 arrays by architecture indices
            temp_trees_index, temp_trees = (list(t) for t in zip(
                *sorted(zip(built_trees_architecture_indices, built_trees))))

            # order outputs and erase duplicates
            for tree, tree_index in zip(temp_trees, temp_trees_index):
                new_tree_index, new_tree = (list(t) for t in zip(*sorted(zip(tree_index, tree))))
                # TODO check if inside new_tree_architecture in ordered_built_trees_architecture and if not append!
                is_unique = True
                for unique_tree in unique_trees_architecture:
                    already_in = True
                    for part_i in range(len(unique_tree)):
                        # test = unique_tree[part_i][0].get_order_key()
                        if len(unique_tree[part_i]) != len(new_tree[part_i]) or any(unique_tree[part_i][i_unique_part].get_order_key() != new_tree[part_i][i_unique_part].get_order_key() for i_unique_part in range(len(unique_tree[part_i]))):
                        # if len(unique_tree[part_i]) != len(new_tree[part_i]) or any(unique_tree[part_i][i_unique_part].order_key != new_tree[part_i][i_unique_part].order_key for i_unique_part in range(len(unique_tree[part_i]))):
                        # if unique_tree[part_i].order_key != new_tree[part_i].order_key:
                            already_in = False
                            break
                    if already_in:
                        is_unique = False
                        break

                if is_unique:
                    unique_trees_architecture.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:
                    #
                    #     ordered_built_trees_architecture.append(tree_architecture)
                    #     ordered_built_trees.append(tree)
                # print("test")
        # for answer1_i, answer1 in enumerate(separated_answers):
        #     for answer2_i, answer2 in enumerate(separated_answers):
        #         if answer1_i != answer2_i:
        #             res, res_i = self.merge_answer(answer1, answer2, answer1_i, answer2_i)
        #             print('aaa')
        #
        # pass
        return l_ordered_built_trees