def _validate_model_config(req, resp, resource, params):
doc = req.context['doc']
mandatory_fields = ['serviceid', 'text']
assert dict_contains(
doc,
mandatory_fields) is True, GenerateVariationsResource._bad_request(
)
def _validate_model_config(req, resp, resource, params):
doc = req.context['doc']
mandatory_fields = ['serviceid']
if not dict_contains(doc, mandatory_fields):
description = 'Mandatory params missing from the request. ' \
'Please check your request params and retry'
logger.exception(description)
raise HTTPBadRequest("HTTP Bad Request", description)
def _instantiate(configuration):
assert dict_contains(configuration, ['class']), \
"build_feature_selector: missing mandatory class"
params = copy.copy(
configuration["params"]) if 'params' in configuration else {}
if 'score_func' in params:
params['score_func'] = get_function(params['score_func'])
return create_instance(configuration["class"], **params)
def __build_selector(self):
"""
Method for building machine learning feature selections configurations
"""
assert isinstance(self.config, dict), \
"Estimator: __build_selector: invalid configuration"
if dict_contains(self.config, ['selector']):
selector_config = self.config['selector']
return build_feature_selector(selector_config)
def _build_cross_validation(self, y=None):
if dict_contains(self.config, "cross_validation"):
cv_config = self.config["cross_validation"]
params = cv_config["params"] if 'params' in cv_config else {}
if y is not None:
params["y"] = y
return create_instance(cv_config['class'], **params)
return StratifiedShuffleSplit(n_splits=5,
test_size=0.33,
random_state=42)
def __build_extractor(self):
"""
Method for building machine learning pre processing configurations
"""
assert isinstance(self.config, dict), \
"Estimator: __build_extractor: invalid configuration"
assert dict_contains(self.config, ['preprocessors']), \
"Estimator: __build_extractor: missing mandatory preprocessors"
preprocessor_config = self.config['preprocessors']
return build_dataframe_mapper(preprocessor_config)
def validate_prediction_request(doc):
"""
:param doc:
:return:
"""
mandatory_fields = ['text', 'serviceid']
if not dict_contains(doc, mandatory_fields):
error = 'Mandatory params missing from the request. ' \
'Please check your request params and retry'
logger.exception(error)
raise HTTPBadRequest("HTTP Bad Request", error)
def _validate_tag_request(req, resp, resource, params):
"""
:param req:
:param resp:
:param resource:
:param params:
:return:
"""
doc = req.context['doc']
mandatory_fields = ['text', 'serviceid']
if not dict_contains(doc, mandatory_fields):
description = 'Mandatory params missing from the request. ' \
'Please check your request params and retry'
logger.exception(description)
raise HTTPBadRequest("HTTP Bad Request", description)
def on_post(self, req, resp):
try:
doc = req.context['doc']
language = "EN"
if dict_contains(doc, 'language'):
language = doc['language']
ice_entity_config = IceEntitiesModelManager().get_ice_entities(
language)
predefined_entity_mappings = PreTrainedEntityModelManager(
).get_entity_models(language)
predefined_entity_models = group_entities(
ice_entity_config, predefined_entity_mappings)
results = {
"predefined_entity_models":
predefined_entity_models,
"custom_entity_models":
CustomEntityModelManager().get_entity_models(language),
"default_predefined_modelClass":
default_predefined_modelClass_dic[language],
"default_custom_modelClass":
default_custom_modelClass_dic[language]
}
resp.data = results
except AssertionError as ae:
logger.exception(ae, exc_info=True)
logger.error(traceback.format_exc())
raise falcon.HTTPPreconditionFailed(
'Service publish condition failed', traceback.format_exc())
except Exception as ex:
logger.exception(ex, exc_info=True)
description = 'Internal Server Error, Please try again later'
raise falcon.HTTPServiceUnavailable('Service Outage', description,
30)
resp.set_header('X-Powered-By', 'USTGlobal ICE')
resp.status = falcon.HTTP_200
def _validate_model_config(req, resp, resource, params):
doc = req.context['doc'] or {}
mandatory_fields = ['serviceid']
assert dict_contains(
doc,
mandatory_fields) is True, ValidateParseResource._bad_request()
def _validate_model_config(req, resp, resource, params):
doc = req.context['doc'] or {}
mandatory_fields = ['serviceid', 'timestamp']
assert dict_contains(
doc, mandatory_fields) is True, ReportFetchResource._bad_request()
def _validate_model_config(req, resp, resource, params):
doc = req.context['doc']
mandatory_fields = ['text']
assert dict_contains(
doc,
mandatory_fields) is True, TokenizeParseResource._bad_request()
def _validate_model_config(req, resp, resource, params):
doc = req.context['doc']
mandatory_fields = ['name']
assert dict_contains(
doc,
mandatory_fields) is True, PhraseRemoveResource._bad_request()