Integrate elements.

* Move interface to KnowledgeBase object.
 * Connect process and evaluate calls.

naive-nlu/knowledge_base.py

@@ -1,8 +1,59 @@
-import collections
+import copy
 
-KnowledgeBase = collections.namedtuple('KnowledgeBase',
-                                       [
-                                           'examples',   # Language examples
-                                           'knowledge',  # Knowledge about the world
-                                           'trained',
-                                       ])
+import parsing
+import knowledge_evaluation
+
+
+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)
+            knowledge_evaluation.integrate_information(self.knowledge, {
+                "elements": tokens,
+                "decomposition": decomposition,
+                "parsed": inferred_tree,
+            })
+            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)
+        decomposition, inferred_tree = parsing.get_fit(self, row)
+        result = knowledge_evaluation.integrate_information(self.knowledge,
+                                                          {
+                                                              "elements": row,
+                                                              "decomposition": decomposition,
+                                                              "parsed": inferred_tree,
+                                                          })
+        knowledge_after = copy.deepcopy(self.knowledge)
+        knowledge_diff_getter = lambda: diff_knowledge(knowledge_before,
+                                                       knowledge_after)
+
+        return result, knowledge_diff_getter