Change prints into loggings.

naive-nlu/tree_nlu/knowledge_evaluation.py

@@ -11,7 +11,7 @@ def resolve(knowledge_base, elements, value):
     if isinstance(value, int):
         return elements[value]
     elif isinstance(value, tuple) or isinstance(value, list):
-        print("V:", value, elements)
+        logging.debug("V: {} {}".format(value, elements))
         return integrate_information(knowledge_base, {
             "elements": elements,
             "parsed": value,
@@ -103,17 +103,15 @@ def exists_property_with_value(knowledge_base, elements, subj, value):
 
 
 def modifiable_element_for_existance_in_set(container, set_name, element):
-    print("-----({} {} {})".format(container, set_name, element))
+    logging.debug("-----({} {} {})".format(container, set_name, element))
-    import traceback
-    # traceback.print_stack()
 
     def getter():
         nonlocal container, set_name, element
-        print("  get({} {} {})".format(container, set_name, element))
+        logging.debug("  get({} {} {})".format(container, set_name, element))
         return (set_name in container) and (element in container[set_name])
 
     def setter():
-        print("  add({} {} {})".format(container, set_name, element))
+        logging.debug("  add({} {} {})".format(container, set_name, element))
         nonlocal container, set_name, element
         return container[set_name].add(element)
 

naive-nlu/tree_nlu/parsing.py

@@ -107,7 +107,7 @@ def integrate_language(knowledge_base, example):
             logging.debug("-FRM- | {}".format(tokens))
             logging.debug("-AFT- | {}".format(after_remix))
 
-            print()
+            logging.debug("--- TEMPLATE ---")
 
             _, matcher, result = make_template(knowledge_base, after_remix, atom)
             logging.debug("Tx: {}".format(after_remix))
@@ -382,9 +382,9 @@ def get_fit(knowledge, tokens, remaining_recursions=parameters.MAX_RECURSIONS):
 
         if result is not None:
             results.append(result)
-            print("XXX", result)
+            logging.debug("XXX {}".format(result))
 
-    print(' - ' + '\n - '.join(map(str, results)))
+    logging.debug(' - ' + '\n - '.join(map(str, results)))
     if len(results) > 0:
         return results[0]
 
@@ -414,14 +414,6 @@ def resolve_fit(knowledge, fit, remaining_recursions):
             if remixed_tokens is None:
                 return None
 
-            # if len(tokens) == 3 and tokens[2] == 'electricity':
-            #     logging.debug("--UNMIX--")
-            #     logging.debug("-MIX- | {}".format(remixer))
-            #     logging.debug("REMIX | {}".format(tokens))
-            #     logging.debug(" T O  | {}".format(remixed_tokens))
-            #     if remixer != [0, 1, 2]:
-            #         return None
-
             minifit = get_fit(knowledge, remixed_tokens, remaining_recursions - 1)
             if minifit is None:
                 return None
@@ -437,27 +429,36 @@ def resolve_fit(knowledge, fit, remaining_recursions):
 def match_fit(knowledge, tokens, matcher, ast, remaining_recursions):
     segment_possibilities = [([], tokens)]  # Matched tokens, remaining tokens
     indent = ' ' * (parameters.MAX_RECURSIONS - remaining_recursions)
+    logging.debug(indent + 'T>', tokens)
+    logging.debug(indent + 'M>', matcher)
     for minisegment in matcher:
         possibilities_after_round = []
+        logging.debug(indent + "MS", minisegment)
         for matched_tokens, remaining_tokens in segment_possibilities:
             if len(remaining_tokens) < 1:
                 continue
 
+            logging.debug(indent + "RT", remaining_tokens[0])
+            logging.debug(indent + "DEF", is_definite_minisegment(minisegment))
             if is_definite_minisegment(minisegment):
+                # What if not match -----<
                 if match_token(knowledge, remaining_tokens[0], minisegment):
                     possibilities_after_round.append((
                         matched_tokens + [remaining_tokens[0]],
                         remaining_tokens[1:]
                     ))
             else:
+                # What if not match!!!!!!-----<
                 # TODO: optimize this with a look ahead
                 for i in range(1, len(tokens)):
                     possibilities_after_round.append((
                         matched_tokens + [(minisegment, remaining_tokens[:i])],
                         remaining_tokens[i:]
                     ))
+            logging.debug(indent + "## PA", len(possibilities_after_round))
         else:
             segment_possibilities = possibilities_after_round
+            logging.debug(">>>> {}".format(len(segment_possibilities)))
 
     fully_matched_segments = [(matched, remaining)
                               for (matched, remaining)
@@ -466,11 +467,11 @@ def match_fit(knowledge, tokens, matcher, ast, remaining_recursions):
 
     resolved_fits = []
     for fit, _ in fully_matched_segments:
-        print(indent + ":::", fit) # REMIXES HAVE TO BE APPLIED BEFORE!!!
+        logging.debug(indent + ":::", fit) # REMIXES HAVE TO BE APPLIED BEFORE!!!
 
-    print(indent + '*' * 20)
+    logging.debug(indent + '*' * 20)
     for fit, _ in fully_matched_segments:
-        print(indent + ":::", fit) # REMIXES HAVE TO BE APPLIED BEFORE!!!
+        logging.debug(indent + ":::", fit) # REMIXES HAVE TO BE APPLIED BEFORE!!!
         resolved_fit = resolve_fit(knowledge, fit, remaining_recursions)
         if resolved_fit is not None:
             resolved_fits.append(resolved_fit)

naive-nlu/tree_nlu/test.py

@@ -3,7 +3,7 @@ import logging
 from .tests import basic
 from .tests import gac_100
 
-logging.getLogger().setLevel(logging.DEBUG)
+logging.getLogger().setLevel(logging.ERROR)
 
 tests = (
     ("basic", basic),
@@ -26,6 +26,7 @@ def main():
             print(" \x1b[1;7;31m!\x1b[0m {}\n [Exception] {}".format(test_name, e))
             failed = True
             traceback.print_exc()
+            raise
 
     if failed:
         exit(1)

naive-nlu/tree_nlu/tests/gac_100.py

@@ -6,7 +6,7 @@ def _assert(args):
     assert(args)
 
 def _assert_msg(args, msg):
-    assert(args, msg)
+    assert args, msg
 
 examples = [
     ('full_example',
@@ -94,7 +94,7 @@ examples = [
                     ('perform-verb-over-object', 'computers', 'use', 'electricity')),
          "answer": True,
          "after_execution": [(
-             lambda knowledge: print("->", knowledge.knowledge['computers'])
+             lambda knowledge: _assert('electricity' in knowledge.knowledge['computers']['performs-over']['use'])
          ),],
      }),
     ('full_example',
@@ -712,7 +712,7 @@ def main():
 
             show_progbar(i, total, data['text'])
             differences = knowledge.train([question])
-            print(differences())
+            logging.debug(differences())
 
             result, _, _ = knowledge.process(data['text'])