def train(self, request):
# if not set will use the default project name, e.g. "default"
project = parameter_or_default(request, "project", default=None)
# if set will not generate a model name but use the passed one
model_name = parameter_or_default(request, "model", default=None)
try:
model_config, data = self.extract_data_and_config(request)
except Exception as e:
request.setResponseCode(400)
returnValue(json_to_string({"error": "{}".format(e)}))
data_file = dump_to_data_file(data)
request.setHeader('Content-Type', 'application/json')
try:
request.setResponseCode(200)
response = yield self.data_router.start_train_process(
data_file, project,
RasaNLUModelConfig(model_config), model_name)
returnValue(json_to_string({'info': 'new model trained: {}'
''.format(response)}))
except MaxTrainingError as e:
request.setResponseCode(403)
returnValue(json_to_string({"error": "{}".format(e)}))
except InvalidProjectError as e:
request.setResponseCode(404)
returnValue(json_to_string({"error": "{}".format(e)}))
except TrainingException as e:
request.setResponseCode(500)
returnValue(json_to_string({"error": "{}".format(e)}))
def parse(self, request):
request.setHeader('Content-Type', 'application/json')
if request.method.decode('utf-8', 'strict') == 'GET':
request_params = decode_parameters(request)
else:
request_params = simplejson.loads(request.content.read().decode(
'utf-8', 'strict'))
if 'query' in request_params:
request_params['q'] = request_params.pop('query')
if 'q' not in request_params:
request.setResponseCode(404)
dumped = json_to_string(
{"error": "Invalid parse parameter specified"})
returnValue(dumped)
else:
try:
request.setResponseCode(200)
response = yield self.data_router.inference(
request_params['q'])
returnValue(json_to_string(response))
except Exception as e:
request.setResponseCode(500)
logger.exception(e)
returnValue(json_to_string({"error": "{}".format(e)}))
def delete(self, request):
request.setHeader('Content-Type', 'application/json')
botId = parameter_or_default(request, "BotRecordId", default=None)
tenanetId = parameter_or_default(request, "TenanetID", default=None)
request.setHeader('Content-Type', 'application/json')
try:
request.setResponseCode(200)
self.data_router.unload_model(tenanetId=tenanetId, botId=botId)
response = yield self.data_router.delete(path="projects",
tenanetId=tenanetId,
botId=botId)
returnValue(json_to_string(response))
except Exception as e:
request.setResponseCode(500)
returnValue(
json_to_string({
"Code": "0",
"Message": "{}".format(e),
"TenanetID": tenanetId,
"BotRecordId": botId
}))
def train(self, request):
try:
model_config, data = self.extract_data_and_config(request)
botId = model_config["BotRecordId"]
tenanetId = model_config["TenanetID"]
except Exception as e:
request.setResponseCode(400)
returnValue(
json_to_string({
"Code": "0",
"Message": "{}".format(e),
"TenanetID": tenanetId,
"BotRecordId": botId
}))
data_file = dump_to_data_file(data)
request.setHeader('Content-Type', 'application/json')
try:
request.setResponseCode(200)
response = yield self.data_router.start_train_process(
data_file, tenanetId, RasaNLUModelConfig(model_config), botId)
returnValue(
json_to_string({
'Code': '1',
"Message": "",
"TenanetID": tenanetId,
"BotRecordId": botId
}))
except MaxTrainingError as e:
request.setResponseCode(403)
returnValue(
json_to_string({
"Code": "0",
"Message": "{}".format(e),
"TenanetID": tenanetId,
"BotRecordId": botId
}))
except InvalidProjectError as e:
request.setResponseCode(404)
returnValue(
json_to_string({
"Code": "0",
"Message": "{}".format(e),
"TenanetID": tenanetId,
"BotRecordId": botId
}))
except TrainingException as e:
request.setResponseCode(500)
returnValue(
json_to_string({
"Code": "0",
"Message": "{}".format(e),
"TenanetID": tenanetId,
"BotRecordId": botId
}))
def parse(self, request):
start = time.time()
request.setHeader('Content-Type', 'application/json')
if request.method.decode('utf-8', 'strict') == 'GET':
request_params = decode_parameters(request)
else:
request_params = simplejson.loads(request.content.read().decode(
'utf-8', 'strict'))
botId = parameter_or_default(request, "BotRecordId", default="default")
tenanetId = parameter_or_default(request,
"TenanetID",
default="default")
if 'query' in request_params:
request_params['q'] = request_params.pop('query')
if 'q' not in request_params:
request.setResponseCode(404)
dumped = json_to_string({
"error": {
"statusCode": 404,
"message": "Invalid parse parameter specified"
}
})
returnValue(dumped)
else:
data = self.data_router.extract(request_params)
try:
request.setResponseCode(200)
response = yield (self.data_router.parse(data)
if self._testing else threads.deferToThread(
self.data_router.parse, data))
end = time.time()
logger.info("parse time cost %.2f s" % (end - start))
returnValue(json_to_string(response))
except InvalidProjectError as e:
request.setResponseCode(404)
returnValue(
json_to_string({
"error": {
"statusCode": 404,
"message": "{}".format(e)
}
}))
except Exception as e:
request.setResponseCode(500)
logger.exception("error in parse function :" + e)
returnValue(
json_to_string({
"error": {
"statusCode": 500,
"message": "{}".format(e)
}
}))
def dump_to_data_file(data):
if isinstance(data, six.string_types):
data_string = data
else:
data_string = utils.json_to_string(data)
return utils.create_temporary_file(data_string, "_training_data")
def version(self, request):
"""Returns the Rasa server's version"""
request.setHeader('Content-Type', 'application/json')
return json_to_string(
{'version': __version__,
'minimum_compatible_version': MINIMUM_COMPATIBLE_VERSION}
)
def evaluate(self, request):
data_string = request.content.read().decode('utf-8', 'strict')
params = {
key.decode('utf-8', 'strict'): value[0].decode('utf-8', 'strict')
for key, value in request.args.items()
}
request.setHeader('Content-Type', 'application/json')
try:
request.setResponseCode(200)
response = yield self.data_router.evaluate(data_string,
params.get('project'),
params.get('model'))
returnValue(json_to_string(response))
except Exception as e:
request.setResponseCode(500)
returnValue(json_to_string({"error": "{}".format(e)}))
def rasaconfig(self, request):
"""Returns the in-memory configuration of the Rasa server"""
# DEPRECATED: I don't think there is a use case for this endpoint
# anymore - when training a new model, the user should always post
# the configuration as part of the request instead of relying on
# the servers config.
request.setHeader('Content-Type', 'application/json')
return json_to_string(self.default_model_config)
def dump_to_data_file(data):
if isinstance(data, six.string_types):
data_string = data
else:
if "rasa_nlu_data" in data:
if "common_examples" in data["rasa_nlu_data"]:
common_examples = data["rasa_nlu_data"]["common_examples"]
# indices = np.random.permutation(len(common_examples))
# common_examples =common_examples[indices]
np.random.shuffle(common_examples)
data["rasa_nlu_data"]["common_examples"] = common_examples
data_string = utils.json_to_string(data)
return utils.create_temporary_file(data_string, "_training_data")
def dumps(self, training_data, **kwargs):
"""Writes Training Data to a string in json format."""
js_entity_synonyms = defaultdict(list)
for k, v in training_data.entity_synonyms.items():
if k != v:
js_entity_synonyms[v].append(k)
formatted_synonyms = [{'value': value, 'synonyms': syns}
for value, syns in js_entity_synonyms.items()]
formatted_examples = [example.as_dict()
for example in training_data.training_examples]
return json_to_string({
"rasa_nlu_data": {
"common_examples": formatted_examples,
"regex_features": training_data.regex_features,
"entity_synonyms": formatted_synonyms
}
}, **kwargs)
def view(self):
return json_to_string(self.__dict__, indent=4)
def status(self, request):
request.setHeader('Content-Type', 'application/json')
return json_to_string(self.data_router.get_status())
