Clean up user agent

Author: vivekraghuram

src/main/nluas/language/user_agent.py

@@ -23,7 +23,6 @@
 from nluas.core_agent import *
 from nluas.language.analyzer_proxy import *
 from nluas.ntuple_decoder import NtupleDecoder
-#from nluas.language.spell_checker import *
 import sys, traceback, time
 import json
 import time
@@ -40,24 +39,20 @@ class UserAgent(CoreAgent):
     def __init__(self, args):
         CoreAgent.__init__(self, args)
         self.initialize_UI()
-        #self.ui_parser = self.setup_ui_parser()
         self.solve_destination = "{}_{}".format(self.federation, "ProblemSolver")
         self.speech_address = "{}_{}".format(self.federation, "SpeechAgent")
         self.text_address = "{}_{}".format(self.federation, "TextAgent")
         self.transport.subscribe(self.solve_destination, self.callback)
         self.transport.subscribe(self.speech_address, self.speech_callback)
         self.transport.subscribe(self.text_address, self.text_callback)
 
-
     def setup_ui_parser(self):
         parser = argparse.ArgumentParser()
         parser.add_argument("-port", type=str, help="indicate host to connect to",
                             default="http://localhost:8090")
         return parser
 
     def initialize_UI(self):
-        #args = self.ui_parser.parse_known_args(self.unknown)
-        #self.analyzer_port = args[0].port
         self.clarification = False
         self.analyzer_port = "http://localhost:8090"
         connected, printed = False, False
@@ -74,7 +69,6 @@ def initialize_UI(self):
                 time.sleep(1)
 
         self.decoder = NtupleDecoder()
-        #self.spell_checker = SpellChecker(self.analyzer.get_lexicon())
 
     def initialize_analyzer(self):
         self.analyzer = Analyzer(self.analyzer_port)
@@ -89,15 +83,12 @@ def initialize_specializer(self):
 
     def match_spans(self, spans, sentence):
         sentence = sentence.replace(".", " . ").replace(",", " , ").replace("?", " ? ").replace("!", " ! ").split()
-        #final = OrderedDict()
-        #word_spans = OrderedDict()
         final = []
         for span in spans:
             lr = span['span']
             final.append([span['type'], sentence[lr[0]:lr[1]], lr, span['id']])
         return final
 
-
     def process_input(self, msg):
         try:
             full_parse = self.analyzer.full_parse(msg)
@@ -110,12 +101,11 @@ def process_input(self, msg):
                     matched = self.match_spans(span, msg)
                     self.specializer.set_spans(matched)
                     ntuple = self.specializer.specialize(fs)
-
-                    #json_ntuple = self.decoder.convert_to_JSON(ntuple)
                     return ntuple
                 except Exception as e:
-                    #self.output_stream(self.name, e)
-                    #traceback.print_exc()
+                    self.verbose:
+                        traceback.print_exc()
+                        self.output_stream(self.name, e)
                     index += 1
         except Exception as e:
             print(e)
@@ -126,20 +116,17 @@ def output_stream(self, tag, message):
 
     def speech_callback(self, ntuple):
         """ Processes text from a SpeechAgent. """
-        #print(ntuple)
-        #ntuple = json.loads(ntuple)
         text = ntuple['text'].lower()
-        print("Got {}".format(text))
+        if self.verbose:
+            print("Got {}".format(text))
         new_ntuple = self.process_input(text)
         if new_ntuple and new_ntuple != "null" and "predicate_type" in new_ntuple:
             self.transport.send(self.solve_destination, new_ntuple)
 
 
     def text_callback(self, ntuple):
         """ Processes text from a SpeechAgent. """
-        #print(ntuple)
         specialize = True
-        #ntuple = json.loads(ntuple)
         msg = ntuple['text']
         if self.is_quit(ntuple):
             self.close()
@@ -162,8 +149,6 @@ def text_callback(self, ntuple):
 
 
     def callback(self, ntuple):
-        print(ntuple)
-        #ntuple = self.decoder.convert_JSON_to_ntuple(ntuple)
         call_type = ntuple['type']
         if call_type == "id_failure":
             self.output_stream(ntuple['tag'], ntuple['message'])
@@ -181,15 +166,13 @@ def write_file(self, json_ntuple, msg):
         f = open(generated, "w")
         f.write(json_ntuple)
 
-
-
     def process_clarification(self, tag, msg, ntuple):
         self.clarification = True
-        #self.output_stream(tag, msg)
+        if self.verbose:
+            self.output_stream(tag, msg)
         new_ntuple = {'tag': tag, 'message': msg, 'type': "clarification", 'original': ntuple}
         self.transport.send(self.text_address, new_ntuple)
 
-
     def clarify_ntuple(self, ntuple, descriptor):
         """ Clarifies a tagged ntuple with new descriptor. """
         new = dict()
@@ -203,20 +186,5 @@ def clarify_ntuple(self, ntuple, descriptor):
                 new[key] = value
         return new
 
-    def check_spelling(self, msg):
-        table = self.spell_checker.spell_check(msg)
-        if table:
-            checked =self.spell_checker.join_checked(table['checked'])
-            if checked != msg:
-                print(self.spell_checker.print_modified(table['checked'], table['modified']))
-                affirm = input("Is this what you meant? (y/n) > ")
-                if affirm and affirm[0].lower() == "y":
-                    self.process_input(checked)
-                else:
-                    return
-            else:
-                self.process_input(msg)
-
-
 if __name__ == "__main__":
     ui = UserAgent(sys.argv[1:])