def get_feedback():
email = request.json["email"].lower()
user_id = db_connection.get_user(email)
simplifications = request.json.get("simplifications", None)
feedback_text = request.json.get("feedback_text", "N/A")
website = request.json.get("url", "N/A")
# request_id = request.json.get("request_id", -1)
rating = request.json.get("rating", 0)
logger.info("Received feedback from user {}, rating {} for site {}.\n"
"Feedback text: {}".format(email, rating, website,
feedback_text))
logger.debug("Request: {}".format(request.json))
db_connection.update_session_with_feedback(rating, feedback_text,
simplifications)
if simplifications:
logger.info(simplifications)
# try:
logger.debug("Getting ranker for user: {}".format(user_id))
ranker = get_personalized_ranker(user_id)
logger.debug("Ranker: {}".format(ranker))
logger.debug(" -- Featurizer: {} ({})".format(
ranker.featurizer, hasattr(ranker, "featurizer")))
update_ranker(ranker, user_id, simplifications, rating)
return make_response(statuscodes.OK, "Feedback successful")
else:
msg = "Did not receive any simplifications"
logger.info(msg)
return make_response(statuscodes.NO_SIMPLIFICATIONS_RETURNED, msg)
def get_feedback():
email = request.json["email"].lower()
user_id = db_connection.get_user(email)
if not user_id or user_id is None:
msg = "User ID not available for email address {}".format(email)
logger.error(msg)
return make_response(statuscodes.EMAIL_ADDRESS_NOT_FOUND, msg)
simplifications = request.json.get("simplifications", None)
feedback_text = request.json.get("feedback_text", "N/A")
website = request.json.get("url", "N/A")
# request_id = request.json.get("request_id", -1)
rating = request.json.get("rating", 0)
logger.info("Received feedback from user {}, rating {} for site {}. "
"Feedback text: {}".format(email, rating, website,
feedback_text))
logger.debug("Request: {}".format(request.json))
db_connection.update_session_with_feedback(rating, feedback_text,
simplifications)
if simplifications:
logger.info(str(simplifications)[:100] + "...")
# try:
logger.debug("Getting cwi & ranker for user: {}".format(user_id))
cwi = get_personalized_cwi(user_id)
ranker = get_personalized_ranker(user_id, nrr_featurizer)
logger.debug("CWI: {}".format(cwi))
logger.debug("Ranker: {}".format(ranker))
update_cwi_and_ranker(cwi, ranker, user_id, simplifications, rating)
return make_response(statuscodes.OK, "Feedback successful")
else:
msg = "Did not receive any simplifications"
logger.info(msg)
return make_response(statuscodes.NO_SIMPLIFICATIONS_RETURNED, msg)
def process():
if not db_connection.test_connection():
msg = "Could not connect to database."
logger.error(msg)
return make_response(statuscodes.DATABASE_CONNECTION_ERROR, msg)
email = request.json["email"].lower()
website_url = request.json["url"]
language = request.json.get("languageId")
frontend_version = request.json.get("frontend_version", "N/A")
logger.info(
"Received simplification request from user {} for website {}".format(
email, website_url))
logger.debug("Simplification request: {}".format(request.json))
user_id = db_connection.get_user(email)
if not user_id:
user_id = 1 # default user. TODO issue warning here to user
request_id = db_connection.insert_session(
user_id,
website_url,
frontend_version=frontend_version,
language=language)
if user_id in personalized_rankers:
logger.info("Using personalized ranker, still in memory.")
ranker = personalized_rankers[user_id]
else:
logger.info("Gotta load ranker or use default...")
try:
# retrieve model
model_path = db_connection.get_model_path(user_id)
ranker = OnlineRegressionRanker.staticload(model_path)
except:
logger.warning("Could not load personalized model. "
"Loading default ranker.")
ranker = copy.copy(personalized_rankers["default"])
logger.debug(ranker)
ranker.userId = user_id
personalized_rankers[user_id] = ranker
logger.info("Loaded ranker: " + str(ranker))
min_similarity = request.json.get("min_similarity", 0.65)
if not type(min_similarity) == float:
raise ValueError("'min_similarity' must be a float. You "
"provided a {}".format(type(min_similarity)))
html_out, simplifications = process_html(simplifier,
request.json["html"],
request.json.get("startOffset"),
request.json.get("endOffset"),
ranker,
mode="lexical",
requestId=request_id,
min_similarity=min_similarity,
blacklist=GENERIC_BLACKLIST)
db_connection.update_session_with_simplifications(request_id,
simplifications)
return make_response(statuscodes.OK,
"Simplification successful",
html=html_out,
simplifications=simplifications,
request_id=request_id)
def test_connection():
logger.debug("Connection test from user {}".format(request.json["email"]))
working_fine = db_connection.test_connection()
if working_fine:
return make_response(statuscodes.OK, "Working fine.")
else:
return make_response(statuscodes.DATABASE_CONNECTION_ERROR,
"Something is wrong with the database.")
def process():
# For time logging
t0 = datetime.now()
if not db_connection.test_connection():
msg = "Could not connect to database."
logger.error(msg)
return make_response(statuscodes.DATABASE_CONNECTION_ERROR, msg)
email = request.json["email"].lower()
website_url = request.json["url"]
language = request.json.get("languageId")
frontend_version = request.json.get("frontend_version", "N/A")
logger.info(
"Received simplification request from user {} for website {}".format(
email, website_url))
logger.debug("Simplification request: {}".format(request.json))
user_id = db_connection.get_user(email)
if not user_id or user_id is None:
user_id = 1 # default user. TODO issue warning here to user
logger.info("User ID: {}".format(user_id))
request_id = db_connection.insert_session(
user_id,
website_url,
frontend_version=frontend_version,
language=language)
single_word_request = request.json.get("single_word_request", False)
if not single_word_request:
cwi = get_personalized_cwi(user_id)
ranker = get_personalized_ranker(user_id, nrr_featurizer)
logger.info("Loaded CWI: " + str(cwi))
logger.info("Loaded ranker: " + str(ranker))
min_similarity = request.json.get("min_similarity", 0.65)
if not type(min_similarity) == float:
raise ValueError("'min_similarity' must be a float. You "
"provided a {}".format(type(min_similarity)))
html_out, simplifications = process_html(simplification_pipeline,
request.json["html"],
request.json.get("startOffset"),
request.json.get("endOffset"),
cwi,
ranker,
mode="lexical",
requestId=request_id,
min_similarity=min_similarity,
blacklist=GENERIC_BLACKLIST)
db_connection.update_session_with_simplifications(request_id,
simplifications)
# Logged time for processing
logger.info('Processing time: {}'.format(datetime.now() - t0))
return make_response(statuscodes.OK,
"Simplification successful",
html=html_out,
simplifications=simplifications,
request_id=request_id)
def login_user():
email = request.json["email"].lower()
logger.info("Received login request for user {}".format(email))
user_id = 1
if not user_id or user_id is None:
msg = "Email address {} not found".format(email)
logger.info(msg)
return make_response(statuscodes.EMAIL_ADDRESS_NOT_FOUND, msg)
msg = "OK. Logged on with email {}".format(email)
logger.info(msg)
# db_connection.update_last_login(user_id)
return make_response(statuscodes.OK, "Login successful")
def versioncheck():
frontend_most_recent_version = cfg["frontend"]["most_recent_version"]
download_url = cfg["frontend"]["download_url"]
return make_response(statuscodes.OK,
"Returned most recent frontend version",
most_recent_version=frontend_most_recent_version,
download_url=download_url)
def login_user():
if not db_connection.test_connection():
msg = "Could not connect to database."
logger.error(msg)
return make_response(statuscodes.DATABASE_CONNECTION_ERROR, msg)
email = request.json["email"].lower()
logger.info("Received login request for user {}".format(email))
user_id = db_connection.get_user(email)
if not user_id or user_id is None:
msg = "Email address {} not found".format(email)
logger.info(msg)
return make_response(statuscodes.EMAIL_ADDRESS_NOT_FOUND, msg)
msg = "OK. Logged on with email {}".format(email)
logger.info(msg)
# db_connection.update_last_login(user_id)
return make_response(statuscodes.OK, "Login successful")
def register_user():
# get fields from request
email = request.json["email"].lower()
# pw_hash = request.json["pw_hash"]
year_of_birth = request.json.get("year_of_birth", 1900)
education = request.json.get("education", "N/A")
# get maximum user ID
logger.info("New user: {}".format([email, year_of_birth, education]))
user = 1
if user:
msg = "Email address {} already registered".format(email)
logger.info(msg)
return make_response(statuscodes.EMAIL_ADDRESS_REGISTERED, msg)
else:
new_user_id = 1
model_path = RANKER_PATH_TEMPLATE.format(new_user_id)
return make_response(statuscodes.OK, "Registration successful")
def register_user():
if not db_connection.test_connection():
msg = "Could not connect to database."
logger.error(msg)
return make_response(statuscodes.DATABASE_CONNECTION_ERROR, msg)
# get fields from request
email = request.json["email"].lower()
# pw_hash = request.json["pw_hash"]
year_of_birth = request.json.get("year_of_birth", 1900)
education = request.json.get("education", "N/A")
# get maximum user ID
logger.info("New user: {}".format([email, year_of_birth, education]))
user = db_connection.get_user(email)
if user:
msg = "Email address {} already registered".format(email)
logger.info(msg)
return make_response(statuscodes.EMAIL_ADDRESS_REGISTERED, msg)
else:
new_user_id = db_connection.insert_user(email)
model_path = RANKER_PATH_TEMPLATE.format(new_user_id)
db_connection.insert_model(new_user_id, year_of_birth, education,
model_path, "ranker")
return make_response(statuscodes.OK, "Registration successful")
def process_txt():
email = request.json["email"].lower()
website_url = request.json["url"]
language = request.json.get("languageId")
frontend_version = request.json.get("frontend_version", "N/A")
logger.info("Received simplification request from user {} for website {}"
.format(email, website_url))
logger.debug("Simplification request: {}".format(request.json))
user_id = 1
if not user_id or user_id is None:
user_id = 1 # default user. TODO issue warning here to user
logger.info("User ID: {}".format(user_id))
request_id = str(uuid.uuid1())
# db_connection.insert_session(user_id, website_url,
# frontend_version=frontend_version,
# language=language)
cwi = None
single_word_request = request.json.get("single_word_request", False)
if not single_word_request:
cwi = get_personalized_cwi(user_id)
ranker = get_personalized_ranker(user_id)
logger.info("Loaded CWI: "+str(cwi))
logger.info("Loaded ranker: "+str(ranker))
min_similarity = request.json.get("min_similarity", 0.65)
if not type(min_similarity) == float:
raise ValueError("'min_similarity' must be a float. You "
"provided a {}".format(type(min_similarity)))
simplifications = process_text_lexical(simplification_pipeline,
request.json["text"],
request.json.get("startOffset"),
request.json.get("endOffset"),
cwi, ranker,
requestId=request_id,
min_similarity=min_similarity,
blacklist=GENERIC_BLACKLIST)
return make_response(statuscodes.OK,
"Simplification successful",
simplifications=simplifications,
request_id=request_id)
