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:
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))
returnValue(json_to_string(response))
except InvalidProjectError as e:
request.setResponseCode(404)
returnValue(json_to_string({"error": "{}".format(e)}))
except Exception as e:
request.setResponseCode(500)
logger.exception(e)
returnValue(json_to_string({"error": "{}".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 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 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 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 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 status(self, request):
request.setHeader('Content-Type', 'application/json')
return json_to_string(self.data_router.get_status())
def view(self):
return json_to_string(self.__dict__, indent=4)