Separated basic test.

naive-nlu/tree_nlu/test.py

@@ -1,157 +1,22 @@
-import json
 import logging
+from .tests import basic
 
-logging.getLogger().setLevel(logging.INFO)
+logging.getLogger().setLevel(logging.WARNING)
-
-from .knowledge_base import KnowledgeBase
-from .modifiable_property import is_modifiable_property
-
-examples = [
-    {
-        "text": "icecream is cold",
-        "parsed": ("exists-property-with-value", 'icecream', 'cold'),
-    },
-    {
-        "text": "is icecream cold?",
-        "parsed": ("question", ("exists-property-with-value", 'icecream', 'cold'))
-    },
-    {
-        "text": "lava is dangerous",
-        "parsed": ("exists-property-with-value", 'lava', 'dangerous')
-    },
-    {
-        "text": "is lava dangerous?",
-        "parsed": ("question", ("exists-property-with-value", 'lava', 'dangerous')),
-    },
-    {
-        "text": "earth is a planet",
-        "parsed": ("pertenence-to-group", 'earth', 'planet'),
-    },
-    {
-        "text": "io is a moon",
-        "parsed": ("pertenence-to-group", 'io', 'moon'),
-    },
-    {
-        "text": "is earth a moon?",
-        "parsed": ("question", ("pertenence-to-group", 'earth', 'moon')),
-    },
-    {
-        "text": "Green is a color",
-        "parsed": ("pertenence-to-group", 'green', 'color'),
-    },
-    {
-        "text": "a plane can fly",
-        "parsed": ("has-capacity", 'plane', 'fly')
-    },
-    {
-        "text": "a wale can swim",
-        "parsed": ("has-capacity", 'wale', 'swim')
-    },
-    {
-        "text": "if earth is a planet, it is big",
-        "parsed": ("implies",
-                   ("pertenence-to-group", 'earth', 'planet'),
-                   ("exists-property-with-value", 'earth', 'big')),
-    },
-]
-
-base_knowledge = {
-    'icecream': {
-        "groups": set(['noun', 'object', 'comestible', 'sweet']),
-    },
-    'lava': {
-        "groups": set(['noun', 'object']),
-    },
-    'earth': {
-        "groups": set(['noun', 'object', 'planet']),
-    },
-    'io': {
-        "groups": set(['noun', 'object']),
-    },
-    'green': {
-        "groups": set(['noun', 'color', 'concept']),
-    },
-    'plane': {
-        "groups": set(['noun', 'object', 'vehicle', 'fast']),
-    },
-    'car': {
-        "groups": set(['noun', 'object', 'vehicle', 'slow-ish']),
-    },
-    'wale': {
-        "groups": set(['noun', 'object', 'living-being']),
-    },
-    'cold': {
-        "groups": set(['property', 'temperature']),
-        "as_property": "temperature",
-    },
-    'dangerous': {
-        "groups": set(['property']),
-        "as_property": "safety",
-    },
-    'planet': {
-        "groups": set(['noun', 'group']),
-    },
-    'moon': {
-        "groups": set(['noun', 'group']),
-    },
-    'color': {
-        "groups": set(['property', 'group']),
-    },
-    'fly': {
-        "groups": set(['verb']),
-    },
-    'swim': {
-        "groups": set(['verb']),
-    },
-}
-
-
-def test_assumption(expectedResponse, knowledge, query):
-    logging.info("Query: {}".format(query['text']))
-    logging.info("Expected: {}".format(expectedResponse))
-
-    result, abstract_tree, diff = knowledge.process(query['text'])
-    end_result = result.getter() if is_modifiable_property(result) else result
-
-    logging.info("\x1b[0;3{}mResult: {}\x1b[0m".format("1" if end_result != expectedResponse else "2", end_result))
-    assert(end_result == expectedResponse)
 
+tests = (
+    ("basic", basic),
+)
 
 def main():
-    knowledge = KnowledgeBase(
+    for test_name, test_module in tests:
-        knowledge=base_knowledge,
+        try:
-    )
+            test_module.main()
+            print(" ✓ {}".format(test_name))
+        except AssertionError:
+            print(" ✗ {}".format(test_name))
+        except Exception as e:
+            print(" ! {} {}".format(test_name, e))
 
-    differences = knowledge.train(examples)
-
-    logging.info("----")
-    logging.info(differences())
-    logging.info("----")
-
-    test_assumption(True, knowledge, {'text': 'earth is a planet'})
-    test_assumption(True, knowledge, {'text': 'is lava dangerous?'})
-    for test in [{'text': 'a bus can run'}, {'text': 'io is a moon'}]:
-        row = test['text']
-        result, inferred_tree, differences = knowledge.process(row)
-
-        logging.info("result:", result)
-        logging.info(differences())
-        logging.info("---")
-    logging.info('-----')
-    logging.info(json.dumps(sorted(knowledge.knowledge.keys()), indent=4))
-    logging.info('-----')
-
-    queryTrue = {
-        "text": "is io a moon?",
-        "parsed": ("question", ("pertenence-to-group", "io", "moon"))
-    }
-    queryFalse = {
-        "text": "is io a planet?",
-        "parsed": ("question", ("pertenence-to-group", "io", "planet"))
-    }
-
-    test_assumption(False, knowledge, queryFalse)
-    test_assumption(True, knowledge, queryTrue)
 
 if __name__ == '__main__':
     main()

naive-nlu/tree_nlu/tests/basic.py

@@ -0,0 +1,150 @@
+import logging
+import json
+
+from ..knowledge_base import KnowledgeBase
+from ..modifiable_property import is_modifiable_property
+
+examples = [
+    {
+        "text": "icecream is cold",
+        "parsed": ("exists-property-with-value", 'icecream', 'cold'),
+    },
+    {
+        "text": "is icecream cold?",
+        "parsed": ("question", ("exists-property-with-value", 'icecream', 'cold'))
+    },
+    {
+        "text": "lava is dangerous",
+        "parsed": ("exists-property-with-value", 'lava', 'dangerous')
+    },
+    {
+        "text": "is lava dangerous?",
+        "parsed": ("question", ("exists-property-with-value", 'lava', 'dangerous')),
+    },
+    {
+        "text": "earth is a planet",
+        "parsed": ("pertenence-to-group", 'earth', 'planet'),
+    },
+    {
+        "text": "io is a moon",
+        "parsed": ("pertenence-to-group", 'io', 'moon'),
+    },
+    {
+        "text": "is earth a moon?",
+        "parsed": ("question", ("pertenence-to-group", 'earth', 'moon')),
+    },
+    {
+        "text": "Green is a color",
+        "parsed": ("pertenence-to-group", 'green', 'color'),
+    },
+    {
+        "text": "a plane can fly",
+        "parsed": ("has-capacity", 'plane', 'fly')
+    },
+    {
+        "text": "a wale can swim",
+        "parsed": ("has-capacity", 'wale', 'swim')
+    },
+    # {
+    #     "text": "if earth is a planet, it is big",
+    #     "parsed": ("implies",
+    #                ("pertenence-to-group", 'earth', 'planet'),
+    #                ("exists-property-with-value", 'earth', 'big')),
+    # },
+]
+
+base_knowledge = {
+    'icecream': {
+        "groups": set(['noun', 'object', 'comestible', 'sweet']),
+    },
+    'lava': {
+        "groups": set(['noun', 'object']),
+    },
+    'earth': {
+        "groups": set(['noun', 'object', 'planet']),
+    },
+    'io': {
+        "groups": set(['noun', 'object']),
+    },
+    'green': {
+        "groups": set(['noun', 'color', 'concept']),
+    },
+    'plane': {
+        "groups": set(['noun', 'object', 'vehicle', 'fast']),
+    },
+    'car': {
+        "groups": set(['noun', 'object', 'vehicle', 'slow-ish']),
+    },
+    'wale': {
+        "groups": set(['noun', 'object', 'living-being']),
+    },
+    'cold': {
+        "groups": set(['property', 'temperature']),
+        "as_property": "temperature",
+    },
+    'dangerous': {
+        "groups": set(['property']),
+        "as_property": "safety",
+    },
+    'planet': {
+        "groups": set(['noun', 'group']),
+    },
+    'moon': {
+        "groups": set(['noun', 'group']),
+    },
+    'color': {
+        "groups": set(['property', 'group']),
+    },
+    'fly': {
+        "groups": set(['verb']),
+    },
+    'swim': {
+        "groups": set(['verb']),
+    },
+}
+
+def test_assumption(expectedResponse, knowledge, query):
+    logging.info("Query: {}".format(query['text']))
+    logging.info("Expected: {}".format(expectedResponse))
+
+    result, abstract_tree, diff = knowledge.process(query['text'])
+    end_result = result.getter() if is_modifiable_property(result) else result
+
+    logging.info("\x1b[0;3{}mResult: {}\x1b[0m".format("1" if end_result != expectedResponse else "2", end_result))
+    assert(end_result == expectedResponse)
+
+def main():
+    knowledge = KnowledgeBase(
+        knowledge=base_knowledge,
+    )
+
+    differences = knowledge.train(examples)
+
+    logging.info("----")
+    logging.info(differences())
+    logging.info("----")
+
+    test_assumption(True, knowledge, {'text': 'earth is a planet'})
+    test_assumption(True, knowledge, {'text': 'is lava dangerous?'})
+    for test in [{'text': 'a bus can run'}, {'text': 'io is a moon'}]:
+        row = test['text']
+        result, inferred_tree, differences = knowledge.process(row)
+
+        logging.info("result:", result)
+        logging.info(differences())
+        logging.info("---")
+    logging.info('-----')
+    logging.info(json.dumps(sorted(knowledge.knowledge.keys()), indent=4))
+    logging.info('-----')
+
+    queryTrue = {
+        "text": "is io a moon?",
+        "parsed": ("question", ("pertenence-to-group", "io", "moon"))
+    }
+    queryFalse = {
+        "text": "is io a planet?",
+        "parsed": ("question", ("pertenence-to-group", "io", "planet"))
+    }
+
+    test_assumption(False, knowledge, queryFalse)
+    test_assumption(True, knowledge, queryTrue)