def __init__(self, zpar_model_directory=None, hostname=None, port=None):
"""
Initialize the parser wrapper.
Parameters
----------
zpar_model_directory : str, optional
The path to the directory containing the ZPar constituency model.
hostname : str, optional
The name of the machine on which the ZPar server is running, if any.
port : int, optional
The port at which the ZPar server is running, if any.
Raises
------
OSError
If ZPar couldn't be loaded.
"""
self.zpar_model_directory = zpar_model_directory
if self.zpar_model_directory is None:
self.zpar_model_directory = os.getenv("ZPAR_MODEL_DIR",
"zpar/english")
# TODO: allow pre-tokenized input
self.tokenizer = nltk.data.load('tokenizers/punkt/english.pickle')
self._zpar_proxy = None
self._zpar_ref = None
# if a port is specified, then we want to use the server
if port:
# if no hostname was specified, then try the local machine
hostname = "localhost" if hostname is None else hostname
logging.info(f"Connecting to zpar server at {hostname}:{port} ...")
# see if a server actually exists
connected, server_proxy = self._get_rpc(hostname, port)
if connected:
self._zpar_proxy = server_proxy
else:
logging.warning('Could not connect to zpar server.')
# otherwise, we want to use the python zpar module
else:
logging.info("Trying to locate zpar shared library ...")
try:
# Create a zpar wrapper data structure
z = ZPar(self.zpar_model_directory)
self._zpar_ref = z.get_parser()
except OSError as e:
logging.warning("Could not load zpar via python-zpar."
"Did you set `ZPAR_MODEL_DIR` correctly?")
raise e
def setUp():
"""
set up things we need for the tests
"""
global z, parser
assert 'ZPAR_MODEL_DIR' in os.environ
model_dir = os.environ['ZPAR_MODEL_DIR']
z = ZPar(model_dir)
parser = z.get_parser()
def setUp():
"""
set up things we need for the tests
"""
global z, parser
assert 'ZPAR_MODEL_DIR' in os.environ
model_dir = os.environ['ZPAR_MODEL_DIR']
z = ZPar(model_dir)
parser = z.get_parser()
class StoppableServer(_baseclass):
allow_reuse_address = True
def __init__(self, addr, zpar_model_path, model_list, *args, **kwds):
# store the hostname and port number
self.myhost, self.myport = addr
# store the link to the loaded zpar object
self.z = ZPar(zpar_model_path)
# initialize the parent class
_baseclass.__init__(self, addr, *args, **kwds)
# Call the individual loading functions
# and only register the appropriate methods
if 'tagger' in model_list:
tagger = self.z.get_tagger()
self.register_function(tagger.tag_sentence)
self.register_function(tagger.tag_file)
if 'parser' in model_list:
parser = self.z.get_parser()
self.register_function(parser.parse_sentence)
self.register_function(parser.parse_file)
self.register_function(parser.parse_tagged_sentence)
self.register_function(parser.parse_tagged_file)
if 'depparser' in model_list:
parser = self.z.get_depparser()
self.register_function(parser.dep_parse_sentence)
self.register_function(parser.dep_parse_file)
self.register_function(parser.dep_parse_tagged_sentence)
self.register_function(parser.dep_parse_tagged_file)
# register the function to remotely stop the server
self.register_function(self.stop_server)
self.quit = False
def serve_forever(self):
while not self.quit:
try:
self.handle_request()
except KeyboardInterrupt:
print("\nKeyboard interrupt received, exiting.")
break
self.z.close()
self.server_close()
def stop_server(self):
self.quit = True
return 0, "Server terminated on host %r, port %r" % (self.myhost, self.myport)
def __init__(self, zpar_model_directory=None, hostname=None,
port=None):
self.zpar_model_directory = zpar_model_directory
if self.zpar_model_directory is None:
self.zpar_model_directory = os.getenv('ZPAR_MODEL_DIR',
'zpar/english')
self.tokenizer = nltk.data.load('tokenizers/punkt/english.pickle')
self._zpar_proxy = None
self._zpar_ref = None
# if a port is specified, then we want to use the server
if port:
# if no hostname was specified, then try the local machine
hostname = 'localhost' if not hostname else hostname
logging.info('Trying to connect to zpar server at {}:{} ...'
.format(hostname, port))
# try to see if a server actually exists
connected, server_proxy = self._get_rpc(hostname, port)
if connected:
self._zpar_proxy = server_proxy
else:
logging.warning('Could not connect to zpar server')
# otherwise, we want to use the python zpar module
else:
logging.info('Trying to locate zpar shared library ...')
# get the path to the zpar shared library via the environment
# variable
zpar_library_dir = os.getenv('ZPAR_LIBRARY_DIR', '')
zpar_library_path = os.path.join(zpar_library_dir, 'zpar.so')
try:
# Create a zpar wrapper data structure
z = ZPar(self.zpar_model_directory)
self._zpar_ref = z.get_parser()
except OSError as e:
logging.warning('Could not load zpar via python-zpar. ' +
'Did you set ZPAR_LIBRARY_DIR correctly?' +
'Did you set ZPAR_MODEL_DIR correctly?')
raise e
