def on_get(self, req, resp): """ Handle HTTP GET request """ link_list = {} # output dictionary link_list['errors'] = [] # list of errors if any link_list['linkages'] = [] # list of linkages in requested format try: # logging IPs just in case logging.info("Connection from: " + (", ".join(req.access_route))) # Get input parammeters lang = req.get_param('lang') text = req.get_param('text') mode = req.get_param_as_int('mode') limit = req.get_param_as_int('limit') # If no sentence is specified, then nothing to do... if text == None: logging.debug( "Parameter 'text' is not specified. Nothing to parse.") raise falcon.HTTPBadRequest( "Parameter 'text' is not specified. Nothing to parse.") # Use default language if no language is specified if lang is None: lang = DEFAULT_LANGUAGE logging.info( "'lang' parameter is not specified in request. 'lang' is set to '" + DEFAULT_LANGUAGE + "'") # Use default mode if no or improper value is specified if mode is None or mode < 0 or mode > MAX_MODE_VALUE: mode = DEFAULT_MODE logging.info( "'mode' value is not properly specified in request. 'mode' is set to " + str(mode)) # Use default limit if no value is specified # or value is not within the range [1, MAX_LINKAGE_LIMIT] if limit is None or limit < 1 or limit > MAX_LINKAGE_LIMIT: limit = DEFAULT_LIMIT logging.info( "'limit' value is not properly specified in request. 'limit' is set to " + str(limit)) # Save input parammeters to the output dictionary, just in case someone needs them link_list['lang'] = lang link_list['mode'] = mode link_list['text'] = text link_list['limit'] = limit # Use default dictionary if it was not explicitly specified dict_path = LG_DICT_DEFAULT_PATH + "/" + lang dict_path = lang if not os.path.isdir(dict_path) else dict_path logging.info("Dictionary path used: " + dict_path) # Invoke link-parser, if the parameters are correctly specified po = ParseOptions(verbosity=0, min_null_count=0, max_null_count=999) po.linkage_limit = limit sent = Sentence(text, Dictionary(dict_path), po) logging.debug("Sentence: '" + sent.text + "'") linkages = sent.parse() if mode == MOD_CONSTTREE: for linkage in linkages: link_list['linkages'].append(linkage.constituent_tree()) elif mode == MOD_POSTSCRIPT: for linkage in linkages: link_list['linkages'].append(linkage.postscript()) else: # MOD_DIAGRAM is default mode for linkage in linkages: link_list['linkages'].append(linkage.diagram()) # Prevent interleaving "Dictionary close" messages po = ParseOptions(verbosity=0) except LG_Error as err: error_msg = "LG_Error: " + str(err) link_list["errors"].append(error_msg) logging.error(error_msg) except Exception as err: error_msg = "Exception: " + str(err) link_list["errors"].append(error_msg) logging.error(error_msg) except BaseException as err: error_msg = "BaseException: " + str(err) link_list["errors"].append(error_msg) logging.error(error_msg) except: error_msg = "Unhandled exception." link_list["errors"].append(error_msg) logging.error(error_msg) # Return proper JSON output resp.body = json.dumps(link_list) resp.status = falcon.HTTP_200
def test_setting_linkage_limit(self): po = ParseOptions() po.linkage_limit = 3 self.assertEqual(clg.parse_options_get_linkage_limit(po._obj), 3)
def setUpClass(cls): cls.d, cls.po = Dictionary(lang='ru'), ParseOptions()
def setUp(self): self.d, self.po = Dictionary(lang='en'), ParseOptions() self.po = ParseOptions(use_sat=True) if self.po.use_sat != True: raise unittest.SkipTest("Library not configured with SAT parser")
def test_setting_verbosity_to_not_allow_value_raises_value_error(self): po = ParseOptions() self.assertRaises(ValueError, setattr, po, "verbosity", 16)
def test_specifying_parse_options(self): po = ParseOptions(linkage_limit=99) self.assertEqual(clg.parse_options_get_linkage_limit(po._obj), 99)
def parse_sent(self, text, po=ParseOptions()): return list(Sentence(text, self.d, po).parse())
def test_setting_min_null_count_to_non_integer_raises_type_error(self): po = ParseOptions() self.assertRaises(TypeError, setattr, po, "min_null_count", "a")
def test_setting_max_null_count(self): po = ParseOptions() po.max_null_count = 3 self.assertEqual(clg.parse_options_get_max_null_count(po._obj), 3)
def test_setting_disjunct_cost(self): po = ParseOptions() po.disjunct_cost = 3.0 self.assertEqual(clg.parse_options_get_disjunct_cost(po._obj), 3.0)
def test_setting_disjunct_cost_to_non_integer_raises_type_error(self): po = ParseOptions() self.assertRaises(TypeError, setattr, po, "disjunct_cost", "a")
def test_setting_linkage_limit_to_negative_number_raises_value_error(self): po = ParseOptions() self.assertRaises(ValueError, setattr, po, "linkage_limit", -1)
def setUp(self): self.d, self.po = Dictionary(), ParseOptions()
#! /usr/bin/env python # -*- coding: utf8 -*- """Link Grammar example usage""" from linkgrammar import Sentence, ParseOptions, Dictionary, Clinkgrammar as clg print("Version:", clg.linkgrammar_get_version()) po = ParseOptions(verbosity=1) def desc(lkg): print(lkg.diagram()) print('Postscript:') print(lkg.postscript()) print('---') def s(q): return '' if q == 1 else 's' def linkage_stat(psent, lang, lkgs, sent_po): """ This function mimics the linkage status report style of link-parser """ random = ' of {} random linkages'. \ format(clg.sentence_num_linkages_post_processed((psent._obj))) \ if clg.sentence_num_linkages_found(psent._obj) > sent_po.linkage_limit else '' print('{}: Found {} linkage{} ({}{} had no P.P. violations)'.format( lang, clg.sentence_num_linkages_found(psent._obj),
def test_setting_spell_guess_to_non_integer_raises_type_error(self): po = ParseOptions() self.assertRaises(TypeError, setattr, po, "spell_guess", "a")
def test_setting_max_null_count_to_negative_number_raises_value_error( self): po = ParseOptions() self.assertRaises(ValueError, setattr, po, "max_null_count", -1)
def test_setting_all_short_connectors_to_non_boolean_raises_type_error( self): po = ParseOptions() self.assertRaises(TypeError, setattr, po, "all_short_connectors", "a")
def test_setting_short_length(self): po = ParseOptions() po.short_length = 3 self.assertEqual(clg.parse_options_get_short_length(po._obj), 3)
def test_that_invalid_option_properties_cannot_be_used(self): po = ParseOptions() self.assertRaisesRegexp(TypeError, "Unknown parse option", setattr, po, "invalid_option", 1)
def test_setting_short_length_to_non_integer_raises_type_error(self): po = ParseOptions() self.assertRaises(TypeError, setattr, po, "short_length", "a")
def test_timer_exhausted_exception(self): self.po = ParseOptions(max_parse_time=1) self.assertRaises( LG_TimerExhausted, self.parse_sent, "This should take more than one second to parse! " * 20, self.po)
def test_setting_short_length_to_negative_number_raises_value_error(self): po = ParseOptions() self.assertRaises(ValueError, setattr, po, "short_length", -1)
def setUpClass(cls): cls.d, cls.po = Dictionary(), ParseOptions()
def test_setting_islands_ok_to_non_boolean_raises_type_error(self): po = ParseOptions() self.assertRaises(TypeError, setattr, po, "islands_ok", "a")
def test_setting_verbosity_to_non_integer_raises_type_error(self): po = ParseOptions() self.assertRaises(TypeError, setattr, po, "verbosity", "a")
def test_setting_max_parse_time(self): po = ParseOptions() po.max_parse_time = 3 self.assertEqual(clg.parse_options_get_max_parse_time(po._obj), 3)
def setUp(self): self.d, self.po = Dictionary(lang='lt'), ParseOptions()
def test_setting_max_parse_time_to_non_integer_raises_type_error(self): po = ParseOptions() self.assertRaises(TypeError, setattr, po, "max_parse_time", "a")
def test_setting_linkage_limit_to_non_integer_raises_type_error(self): po = ParseOptions() self.assertRaises(TypeError, setattr, po, "linkage_limit", "a")
help="do not display morphology") args.add_argument("-i", "--interactive", action="store_true", help="interactive mode after each result") arg = args.parse_args() try: lgdict = Dictionary(arg.lang) except LG_Error: # The default error handler will print the error message args.print_usage() sys.exit(2) po = ParseOptions(verbosity=arg.verbosity) po.max_null_count = 999 # > allowed maximum number of words po.linkage_limit = 10000 # maximum number of linkages to generate po.max_parse_time = 10 # actual parse timeout may be about twice bigger po.spell_guess = True if DISPLAY_GUESSES else False po.display_morphology = arg.morphology while True: try: sentence_text = input(PROMPT) except EOFError: print("EOF") exit(0) if not is_stdin_atty and sentence_text: