def print_help():
announce('ccg2lambda QA Assistant: Help')
info(' › q, quit: \tQuits the software')
info(' › ?, h, help: \tDisplays this page')
info(' › v, verbose: \tEnables verbose mode')
# noinspection SpellCheckingInspection
info(' › nv, noverbose:\tDisables verbose mode')
def build(self):
"""
Add triples to the basic query template (sparql/queryBuilder/query_template.sparql) and sends the request
:return: the result of the request.
"""
verbose("Filling variables dictionary...")
self.__fill_dictionary()
for triple in self.__triples:
self.__query += ' ' + triple[0] + ' ' + triple[1] + \
' ' + triple[2] + ' .'
announce("Sending query: " + self.__query)
info("The answer is: " + self.__request())
def main():
announce('Starting ccg2lambda QA Assistant Server...')
from network.server import server
# Here we can register commands if we ever need to
server.register_command('request', request)
server.register_command('choice', client_choice)
# The server starts listening to requests
try:
server.run()
except KeyboardInterrupt:
print('\nThe user killed the server...')
def run(self):
"""
Launches this server. This method will block, and clients will begin to be handled.
"""
announce("Server: Running")
while self.is_running:
try:
self.socket.settimeout(1)
client, infos = self.socket.accept()
Thread(target=self.__connect_to_client, args=[client]).start()
except (socket.timeout, OSError):
pass
warning("Server: The socket was closed, stopped listening.")
def choose(client, *args: str):
verbose('The server is asking:', *args)
announce('\nWhat did you mean?')
options = [arg.replace('~', ' ').split('|') for arg in args]
for option in options:
print(' › ' + option[0] + '\t\x1b[32m' + option[1] + '\x1b[0m\t' +
option[2] + ' \x1b[1;35mhttps:' + option[3] + '\x1b[0m')
while True:
user: str = input("Type the number of your choice: ")
user_i: int = int(user)
if 0 <= user_i < len(options):
break
client.send('choice', str(user))
def main():
announce("\n Starting...")
print_help()
while True:
user = input("\nSend a request to the server: ")
# noinspection SpellCheckingInspection
if user == "quit" or user == "q":
break
elif user == "help" or user == "h" or user == "?":
print_help()
elif user == "verbose" or user == "v":
set_verbose(True)
elif user == "noverbose" or user == "nv":
set_verbose(False)
else:
try:
request_sentence(user)
except ConnectionRefusedError:
warning('Server unreachable. Please check that it is running.')
announce('Stopping')
def convert(sentences: List[str], output_file=False) -> List[Expression]:
"""
Converts a list of questions to an Abstract Syntax Tree (AST), using:
- spaCy to annotate each word with its grammatical class,
- depccg to convert the natural language to a CCG tree,
- ccg2lambda to convert the CCG tree to a λ expressions,
- nltk to parse that λ-expressions into an AST represented in Python objects.
:param output_file: if True, will output an xml file of the parsed sentences
:param sentences: a list of questions in English
:exception if less than 1 sentence is provided
:return a list of ASTs that each correspond to one of the given sentences (in the same order).
"""
if len(sentences) < 1:
raise Exception("Cannot run the pipeline with less than 1 sentence: " +
str(len(sentences)))
announce("Beginning conversion of", len(sentences),
"sentences, the first one is [", sentences[0], "]")
annotated_sentences, split_sentences = __annotate_spacy(sentences)
ccg_of_each_sentence = __convert_to_ccg(split_sentences)
lambda_expressions = __ccg_to_jigg_xml(ccg_of_each_sentence,
annotated_sentences)
formulas = __ccg_jigg_xml_to_lambda(lambda_expressions)
# Creates an XML file to be used
if output_file:
# Can be used in ccg2lambda python script visualize.py to output
# sentences.html to give better overview
info("Creating visualisation in file sentences.sem.xml")
visualisation.visualize(lambda_expressions, "sentences.html")
expr = __lambda_to_python(formulas)
verbose("Conversion done.")
return expr