lang-model/naive-nlu/knowledge_base.py

import copy

import parsing
import knowledge_evaluation
from modifiable_property import ModifiableProperty


def diff_knowledge(before, after):
    import jsondiff
    return jsondiff.diff(before, after)


class KnowledgeBase(object):
    def __init__(self, knowledge, examples=[], trained=[]):
        self.knowledge = copy.copy(knowledge)
        self.examples = copy.copy(examples)
        self.trained = copy.copy(trained)

    def train(self, examples):
        knowledge_before = copy.deepcopy(self.knowledge)

        # Parse everything
        parsed_examples = []
        for example in examples:
            tokens, decomposition, inferred_tree = parsing.integrate_language(self, example)
            print(tokens)
            result = knowledge_evaluation.integrate_information(self.knowledge, {
                "elements": tokens,
                "decomposition": decomposition,
                "parsed": inferred_tree,
            })
            self.act_upon(result)
            parsed_examples.append((decomposition, inferred_tree))

        # Reduce values
        trained = parsing.reprocess_language_knowledge(self, parsed_examples)

        self.examples += parsed_examples
        self.trained = trained

        knowledge_after = copy.deepcopy(self.knowledge)
        knowledge_diff_getter = lambda: diff_knowledge(knowledge_before,
                                                       knowledge_after)

        return knowledge_diff_getter


    def process(self, row):
        knowledge_before = copy.deepcopy(self.knowledge)
        tokens, decomposition, inferred_tree = parsing.get_fit(self, row)
        result = knowledge_evaluation.integrate_information(self.knowledge,
                                                          {
                                                              "elements": tokens,
                                                              "decomposition": decomposition,
                                                              "parsed": inferred_tree,
                                                          })
        self.act_upon(result)

        knowledge_after = copy.deepcopy(self.knowledge)
        knowledge_diff_getter = lambda: diff_knowledge(knowledge_before,
                                                       knowledge_after)

        return result, knowledge_diff_getter

    def act_upon(self, result):
        if isinstance(result, ModifiableProperty):
            result.setter()
        else:
            print(result)