Setup an structure to allow setting or getting elements.

naive-nlu/knowledge_base.py

@@ -2,6 +2,7 @@ import copy
 
 import parsing
 import knowledge_evaluation
+from modifiable_property import ModifiableProperty
 
 
 def diff_knowledge(before, after):
@@ -23,11 +24,12 @@ class KnowledgeBase(object):
         for example in examples:
             tokens, decomposition, inferred_tree = parsing.integrate_language(self, example)
             print(tokens)
-            knowledge_evaluation.integrate_information(self.knowledge, {
+            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
@@ -52,8 +54,16 @@ class KnowledgeBase(object):
                                                               "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)

naive-nlu/knowledge_evaluation.py

@@ -1,6 +1,14 @@
-def resolve(elements, value):
+from modifiable_property import ModifiableProperty
+
+
+def resolve(knowledge_base, elements, value):
     if isinstance(value, int):
         return elements[value]
+    elif isinstance(value, tuple):
+        return integrate_information(knowledge_base, {
+            "elements": elements,
+            "parsed": value,
+        })
     return value
 
 
@@ -10,38 +18,75 @@ def property_for_value(knowledge_base, value):
     return knowledge_base[value]['as_property']
 
 
+def modifiable_property_from_property(prop, path, value):
+    def getter():
+        nonlocal prop, path, value
+        return (path in prop) and prop[path] == value
+
+    def setter():
+        nonlocal prop, path, value
+        prop[path] = value
+
+
 def exists_property_with_value(knowledge_base, elements, subj, value):
-    subj = resolve(elements, subj)
-    value = resolve(elements, value)
+    subj = resolve(knowledge_base, elements, subj)
+    value = resolve(knowledge_base, elements, value)
 
     if subj not in knowledge_base:
         knowledge_base[subj] = {}
 
-    knowledge_base[subj][property_for_value(knowledge_base, value)] = value
+    return modifiable_property_from_property(
+        prop=knowledge_base[subj],
+        path=property_for_value(knowledge_base, value),
+        value=value
+    )
 
 
+def modifiable_element_for_existance_in_set(container, set_name, element):
+    def getter():
+        nonlocal container, set_name, element
+        return (set_name in container) and (element in container[set_name])
+
+    def setter():
+        nonlocal container, set_name, element
+        return container[set_name].add(element)
+    return ModifiableProperty(
+        getter=getter,
+        setter=setter,
+    )
+
 def pertenence_to_group(knowledge_base, elements, subj, group):
-    subj = resolve(elements, subj)
-    group = resolve(elements, group)
+    subj = resolve(knowledge_base, elements, subj)
+    group = resolve(knowledge_base, elements, group)
 
     if subj not in knowledge_base:
         knowledge_base[subj] = {}
 
     if "groups" not in knowledge_base[subj]:
         knowledge_base[subj]["groups"] = set()
-    knowledge_base[subj]["groups"].add(group)
+
+    return modifiable_element_for_existance_in_set(
+        container=knowledge_base[subj],
+        set_name="groups",
+        element=group
+    )
 
 
 def has_capacity(knowledge_base, elements, subj, capacity):
-    subj = resolve(elements, subj)
-    capacity = resolve(elements, capacity)
+    subj = resolve(knowledge_base, elements, subj)
+    capacity = resolve(knowledge_base, elements, capacity)
 
     if subj not in knowledge_base:
         knowledge_base[subj] = {}
 
     if "capacities" not in knowledge_base[subj]:
         knowledge_base[subj]["capacities"] = set()
-    knowledge_base[subj]["capacities"].add(capacity)
+
+    return modifiable_element_for_existance_in_set(
+        container=knowledge_base[subj],
+        set_name="capacities",
+        element=capacity
+    )
 
 
 knowledge_ingestion = {
@@ -56,4 +101,4 @@ def integrate_information(knowledge_base, example):
     args = example['parsed'][1:]
     elements = example.get('elements', None)
 
-    knowledge_ingestion[method](knowledge_base, elements, *args)
+    return knowledge_ingestion[method](knowledge_base, elements, *args)

naive-nlu/modifiable_property.py

@@ -0,0 +1,3 @@
+import collections
+
+ModifiableProperty = collections.namedtuple('ModifiableProperty', ['getter', 'setter'])