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:
