def bots(): if request.method == 'GET': code, user_id = checkAuth(request) if code == 200: bots = Bot.query.filter_by(user_id=user_id) bots_obj = [] for bot in bots: bot_obj = {} bot_obj['id'] = bot.id bot_obj['bot_guid'] = bot.bot_guid bot_obj['user_id'] = bot.user_id bot_obj['name'] = bot.name bot_obj['persona'] = bot.persona bot_obj['last_trained'] = bot.last_trained bot_obj['used'] = ( bot.used - datetime.datetime(1970, 1, 1)).total_seconds() bots_obj.append(bot_obj) app.logger.info('GET /api/bots list of bots returned successfully') return jsonify({"bots": bots_obj}) elif code == 400: app.logger.warning('GET /api/bots invalid authorization token') return jsonify({"error": "Invalid Authorization Token"}), 400 elif code == 401: app.logger.warning('GET /api/bots no authorization token sent') return jsonify({"error": "No Authorization Token Sent"}), 401 elif request.method == 'POST': code, user_id = checkAuth(request) post_data = request.get_json() if not post_data: response_object = {'status': 'fail', 'message': 'Invalid payload.'} app.logger.warning('POST /api/bots post object invalid') return jsonify(response_object), 400 name = post_data.get('name') if code == 200: bot = Bot(user_id=user_id, name=name.lower(), words=json.dumps({})) db.session.add(bot) try: db.session.commit() except Exception as e: app.logger.error('POST /api/bots ' + str(e)) return jsonify({"success": False, "error": str(e)}) app.logger.info('POST /api/bots bot added successfully') return jsonify({'success': True}), 200 elif code == 400: app.logger.warning('POST /api/bots invalid authorization token') return jsonify({"error": "Invalid Authorization Token"}), 400 elif code == 401: app.logger.warning('POST /api/bots no authorization token sent') return jsonify({"error": "No Authorization Token Sent"}), 401
def upload(bot_guid): code, user_id = checkAuth(request) if code == 200: bot = Bot.query.filter_by(bot_guid=bot_guid).first() if bot: if bot.user_id == user_id: #Get the file information file = request.files['file'] filename = secure_filename(file.filename) data = json.load(file) load_from_json(data, bot, bot_guid) app.logger.info('POST /api/upload/' + bot_guid + ' successfully uploaded ozz data') return jsonify({ "filename": filename, "type": file.content_type }) else: app.logger.warning('POST /api/upload/' + bot_guid + ' not authorized') return jsonify({"error": "Not Authorized"}), 401 else: app.logger.warning('POST /api/upload/' + bot_guid + ' bot does not exist') return jsonify({"error": "Bot doesn't exist"}), 404 elif code == 400: app.logger.warning('POST /api/upload/' + bot_guid + ' invalid authorization token') return jsonify({"error": "Invalid Authorization Token"}), 400 elif code == 401: app.logger.warning('POST /api/upload/' + bot_guid + ' no authorization token sent') return jsonify({"error": "No Authorization Token Sent"}), 401
def persona(bot_guid): code, user_id = checkAuth(request) # code = 200 # user_id = 16 if code == 200: bot = Bot.query.filter_by(bot_guid=bot_guid).first() if not bot: return jsonify({"error": "Bot Not Found"}), 404 if bot.user_id == user_id: if request.method == 'GET': return jsonify({"persona": bot.persona}) elif request.method == 'PUT': put_data = request.get_json() try: bot.persona = put_data['persona'] db.session.commit() except Exception as e: app.logger.error('GET /api/bots/' + bot_guid + '/persona ' + str(e)) return jsonify({"success": False, "error": str(e)}) app.logger.info('GET /api/bots/' + bot_guid + '/persona returned persona') return jsonify({"persona": bot.persona}) else: app.logger.warning('/api/bots/' + bot_guid + '/persona Unauthorized') return jsonify({"error": "Unauthorized"}), 401 elif code == 400: app.logger.warning('/api/bots/' + bot_guid + '/persona Invalid Authorization Token') return jsonify({"error": "Invalid Authorization Token"}), 400 elif code == 401: app.logger.warning('/api/bots/' + bot_guid + '/persona No Authorization Token Sent') return jsonify({"error": "No Authorization Token Sent"}), 401
def entity(bot_guid,entity_name): code,user_id = checkAuth(request) if code == 200: bot = Bot.query.filter_by(bot_guid=bot_guid).first() if bot: if bot.user_id == user_id: if request.method == 'GET': entity= Entity.query.filter_by(bot_guid=bot_guid).filter_by(name=entity_name).first() if entity: if type(entity.examples) == str: entity.examples = json.loads(entity.examples) app.logger.info('GET /api/entities/'+bot_guid+'/'+entity_name+' successfully returned entity examples') return jsonify({"examples":entity.examples}) elif request.method == 'POST': post_data = request.get_json() if not post_data: response_object = { 'status': 'fail', 'message': 'Invalid payload.' } app.logger.warning('POST /api/entities/'+bot_guid+'/'+entity_name+' invalid post object') return jsonify(response_object), 400 else: entity= Entity.query.filter_by(bot_guid=bot_guid).filter_by(name=entity_name).first() if entity: if type(entity.examples) == str: entity.examples = json.loads(entity.examples) new_example = post_data['new_example'] entity.examples[new_example] = [] flag_modified(entity, "examples") try: db.session.commit() except Exception as e: app.logger.error('POST /api/entities/'+bot_guid+'/'+entity_name+' '+str(e)) return jsonify({"success":False,"error":str(e)}) app.logger.info('POST /api/entities/'+bot_guid+'/'+entity_name+' successfully added entity') return jsonify({"success":True}) elif request.method == 'DELETE': entity= Entity.query.filter_by(bot_guid=bot_guid).filter_by(name=entity_name).first() if entity: old_example = request.args['old_example'] entity.examples.pop(old_example,0) flag_modified(entity, "examples") try: db.session.commit() except Exception as e: app.logger.error('DELETE /api/entities/'+bot_guid+'/'+entity_name+' '+str(e)) return jsonify({"success":False,"error":str(e)}) app.logger.info('POST /api/entities/'+bot_guid+'/'+entity_name+' successfully deleted entity') return jsonify({"success":True}) elif code == 400: app.logger.warning('/api/entities/'+bot_guid+'/'+entity_name+' invalid authorization token') return jsonify({"error":"Invalid Authorization Token"}),400 elif code == 401: app.logger.warning('/api/entities/'+bot_guid+'/'+entity_name+' no authorization token sent') return jsonify({"error":"No Authorization Token Sent"}),401
def syn(bot_guid, entity_name, example_name): code, user_id = checkAuth(request) if code == 200: bot = Bot.query.filter_by(bot_guid=bot_guid).first() if bot: if bot.user_id == user_id: if request.method == 'POST': post_data = request.get_json() if not post_data: response_object = { 'status': 'fail', 'message': 'Invalid payload.' } return jsonify(response_object), 400 else: entity = Entity.query.filter_by( bot_guid=bot_guid).filter_by( name=entity_name).first() if entity: synonym = post_data['synonym'] if type(entity.examples) == str: entity.examples = json.loads(entity.examples) if example_name in entity.examples: entity.examples[example_name].append(synonym) flag_modified(entity, "examples") try: db.session.commit() except Exception as e: return jsonify({"success": "false"}) return jsonify({"success": "true"}) elif request.method == 'DELETE': entity = Entity.query.filter_by( bot_guid=bot_guid).filter_by(name=entity_name).first() if entity: synonym = request.args['synonym'] if type(entity.examples) == str: entity.examples = json.loads(entity.examples) if example_name in entity.examples: entity.examples[example_name].remove(synonym) flag_modified(entity, "examples") try: db.session.commit() except Exception as e: return jsonify({"success": "false"}) return jsonify({"success": "true"}) elif code == 400: return jsonify({"error": "Invalid Authorization Token"}), 400 elif code == 401: return jsonify({"error": "No Authorization Token Sent"}), 401
def download(bot_guid): code, user_id = checkAuth(request) # code, user_id = 200,16 if code == 200: bot = Bot.query.filter_by(bot_guid=bot_guid).first() if bot: if bot.user_id == user_id: ozz_data = {"ozz_data": {"intents": [], "entities": []}} intents = Intent.query.filter_by(bot_guid=bot_guid).all() entities = Entity.query.filter_by(bot_guid=bot_guid).all() for intent in intents: intent_obj = {} intent_obj['name'] = intent.name intent_obj['utterances'] = intent.utterances intent_obj['responses'] = intent.responses intent_obj['patterns'] = intent.patterns ozz_data['ozz_data']['intents'].append(intent_obj) for entity in entities: ent_obj = {} ent_obj['name'] = entity.name ent_obj['values'] = [] for value in entity.examples: value_obj = {} value_obj['name'] = value value_obj['synonyms'] = entity.examples[value] ent_obj['values'].append(value_obj) ozz_data['ozz_data']['entities'].append(ent_obj) app.logger.info('GET /api/download/' + bot_guid + ' successfully downloaded ozz data') return jsonify(ozz_data) else: app.logger.warning('GET /api/download/' + bot_guid + ' not authorized') return jsonify({"error": "Not Authorized"}), 401 else: app.logger.warning('GET /api/download/' + bot_guid + ' bot does not exist') return jsonify({"error": "Bot doesn't exist"}), 404 elif code == 400: app.logger.warning('GET /api/download/' + bot_guid + ' invalid authorization token') return jsonify({"error": "Invalid Authorization Token"}), 400 elif code == 401: app.logger.warning('GET /api/download/' + bot_guid + ' no authorization token sent') return jsonify({"error": "No Authorization Token Sent"}), 401
def analytics(bot_guid): code,user_id = checkAuth(request) # code = 200 # user_id = 16 if code == 200: bot = Bot.query.filter_by(bot_guid=bot_guid).first() if bot: if request.method == 'GET': if bot.user_id == user_id: analytics_logs = Analytics.query.filter_by(bot_guid=bot_guid).all() intents = Intent.query.filter_by(bot_guid=bot_guid).all() intent_count = {} for intent in intents: intent_count[intent.name] = 0 calls = 0 success_count = 0.0 resp_time = 0.0 times = [] for log in analytics_logs: if log.confident: success_count += 1.0 if log.intent in intent_count: intent_count[log.intent] += 1 resp_time += float(log.response_time) calls += 1 times.append(log.created) avg_resp_time = float("{:.3f}".format(resp_time/calls)) success_percentage = float("{:.3f}".format((success_count/calls) * 100)) app.logger.info('GET /analytics - analytics response success') return jsonify({"calls":calls,"avg_resp_time":avg_resp_time,"success_percentage":success_percentage,"intent_count":intent_count,"times":times}) else: app.logger.warning('GET /analytics not authorized') return jsonify({"error":"Not Authorized"}),401 else: app.logger.warning('/analytics not authorized') return jsonify({"error":"Not Authorized"}),401 else: app.logger.warning('/analytics bot does not exist') return jsonify({"error":"Bot Doesn't exist"}),404 elif code == 400: app.logger.warning('/analytics invalid authorization token') return jsonify({"error":"Invalid Authorization Token"}),400 elif code == 401: app.logger.warning('/analytics no authorization token sent') return jsonify({"error":"No Authorization Token Sent"}),401
def intent(bot_guid,intent_name): code,user_id = checkAuth(request) if code == 200: global interpreters nlus = interpreters bot = Bot.query.filter_by(bot_guid=bot_guid).first() if bot: if bot.user_id == user_id: intent = Intent.query.filter_by(bot_guid=bot_guid).filter_by(name=intent_name).first() if intent: model = bot.active_model if model: nlu = nlus[model] else: nlu = None if request.method == 'GET': intent_obj = {} intent_obj['is_folder'] = False intent_obj['responses'] = intent.responses intent_obj['utterances'] = [] for utterance in intent.utterances: intent_obj['utterances'].append({"utterance":utterance,"entities":[]}) try: db.session.commit() except Exception as e: app.logger.error('GET /api/intents/'+bot_guid+ '/'+ intent_name+ ' ' + str(e)) return jsonify({"success":False,'errors':str(e)}),400 app.logger.info('GET /api/intents/'+bot_guid+ '/'+ intent_name+ ' successfully returned intent information') return jsonify(intent_obj) else: app.logger.warning('/api/intents/'+bot_guid+ '/'+ intent_name+ ' intent does not exist') return jsonify({"error":"Intent Doesn't exist"}),404 else: app.logger.warning('/api/intents/'+bot_guid+ '/'+ intent_name+ ' not authorized') return jsonify({"error":"Not Authorized"}),401 else: app.logger.warning('/api/intents/'+bot_guid+ '/'+ intent_name+ ' bot does not exist') return jsonify({"error":"Bot Doesn't exist"}),404 elif code == 400: app.logger.warning('/api/intents/'+bot_guid+ '/'+ intent_name+ ' invalid authorization token') return jsonify({"error":"Invalid Authorization Token"}),400 elif code == 401: app.logger.warning('/api/intents/'+bot_guid+ '/'+ intent_name+ ' authorization token not sent') return jsonify({"error":"No Authorization Token Sent"}),401
def upload_dialogflow(bot_guid): code, user_id = checkAuth(request) if code == 200: bot = Bot.query.filter_by(bot_guid=bot_guid).first() if bot: if bot.user_id == user_id: #Get the file information file = request.files['file'] filename = secure_filename(file.filename) print(filename) path = os.path.join(os.getcwd(), 'data/dialogflow') file.save(path + '/dialogflow.zip') try: zip_ref = zipfile.ZipFile( os.path.join(path, 'dialogflow.zip'), 'r') zip_ref.extractall(path + '/contents') zip_ref.close() except Exception as e: print(str(e)) app.logger.info('POST /api/upload/' + bot_guid + ' successfully uploaded ozz data') return jsonify({ "filename": filename, "type": file.content_type }) else: app.logger.warning('POST /api/upload/' + bot_guid + ' not authorized') return jsonify({"error": "Not Authorized"}), 401 else: app.logger.warning('POST /api/upload/' + bot_guid + ' bot does not exist') return jsonify({"error": "Bot doesn't exist"}), 404 elif code == 400: app.logger.warning('POST /api/upload/' + bot_guid + ' invalid authorization token') return jsonify({"error": "Invalid Authorization Token"}), 400 elif code == 401: app.logger.warning('POST /api/upload/' + bot_guid + ' no authorization token sent') return jsonify({"error": "No Authorization Token Sent"}), 401
def folders(bot_guid): code,user_id = checkAuth(request) print(code) if code == 200: bot = Bot.query.filter_by(bot_guid=bot_guid).first() if bot: if bot.user_id == user_id: if request.method == 'DELETE': folders = request.args.getlist('folders[]') base = request.args['base'] print(base) try: for folder in folders: pres = '.'.join(base.split('/')[1:]) if base != '/': folder = pres + '.' + folder intent_name = folder + '%' query = Intent.query.filter_by(bot_guid=bot_guid).filter(Intent.name.like(intent_name)) query.delete(synchronize_session=False) db.session.commit() except Exception as e: app.logger.error('DELETE /api/folders/'+bot_guid+ ' ' + str(e)) return jsonify({"success":False,"errors":str(e)}) app.logger.info('DELETE /api/folders/'+bot_guid+ ' successfully deleted folder') return jsonify({"success":True}) else: app.logger.warning('/api/folders/'+bot_guid+ ' method not allowed') return jsonify({"error":"Method Not Allowed"}),405 else: app.logger.warning('/api/folders/'+bot_guid+ ' not authorized') return jsonify({"error":"Not Authorized"}),401 else: app.logger.warning('/api/folders/'+bot_guid+ ' bot not found') return jsonify({"error":"Bot Not Found"}),404 elif code == 400: app.logger.warning('/api/folders/'+bot_guid+ ' invalid authorization token') return jsonify({"error":"Invalid Authorization Token"}),400 elif code == 401: app.logger.warning('/api/folders/'+bot_guid+ ' no authorization token sent') return jsonify({"error":"No Authorization Token Sent"}),401
def uploadexcel(bot_guid): if request.method == 'POST': code, user_id = checkAuth(request) if code == 200: bot = Bot.query.filter_by(bot_guid=bot_guid).first() if bot: if bot.user_id == user_id: tsv_file = request.files['file'] filename = secure_filename(tsv_file.filename) tsv_file_read = tsv_file.readlines() for row in tsv_file_read: line = row.decode('utf-8') intent_name, questions, answers = line.split('\t') questions = questions.split('<->') answers = answers.split('<->') questions = [q for q in questions if len(q) > 0] answers = [a for a in answers if len(a) > 0] if intent_name == 'Intent' or intent_name == 'intent': continue else: intent = Intent.query.filter_by( bot_guid=bot_guid).filter_by( name=intent_name).first() patterns = [] for utt_copy in questions: if len(utt_copy) == 0: continue parameters, regex = get_regex(utt_copy) new_obj = {} new_obj['string'] = utt_copy new_obj['regex'] = regex new_obj['entities'] = parameters new_obj['len'] = len(utt_copy) patterns.append(json.dumps(new_obj)) for word in stopWords: utt_copy = utt_copy.replace(word, " ") utt_words = utt_copy.split(" ") words_json = json.loads(bot.words) if type(words_json) == str: words_json = {} for word in utt_words: if word in words_json: if intent_name in words_json[word]: words_json[word][intent_name] += 1 else: words_json[word][intent_name] = 1 else: words_json[word] = {intent_name: 1} try: if intent: intent.utterances = questions intent.responses += answers intent.patterns = patterns flag_modified(intent, "utterances") flag_modified(intent, "responses") flag_modified(intent, "patterns") db.session.commit() else: name = intent_name utterances = questions responses = answers has_entities = False intent = Intent(name=name, bot_guid=bot_guid, utterances=utterances, has_entities=has_entities, responses=responses, patterns=patterns) db.session.add(intent) db.session.commit() except Exception as e: app.logger.error('POST /api/upload_csv/' + bot_guid + ' ' + str(e)) return jsonify({ "success": False, "errors": str(e) }) app.logger.info('POST /api/upload_csv/' + bot_guid + ' uploaded bot data from csv') return jsonify({"success": True}) else: app.logger.warning('POST /api/upload_csv/' + bot_guid + ' not authorized') return jsonify({"error": "Not Authorized"}), 401 else: app.logger.warning('POST /api/upload_csv/' + bot_guid + ' bot does not exist') return jsonify({"error": "Bot doesn't exist"}), 404 elif code == 400: app.logger.warning('POST /api/upload_csv/' + bot_guid + ' invalid authorization token') return jsonify({"error": "Invalid Authorization Token"}), 400 elif code == 401: app.logger.warning('POST /api/upload_csv/' + bot_guid + ' no authorization token sent') return jsonify({"error": "No Authorization Token Sent"}), 401 return render_template('file.html')
def train(bot_guid): code, user_id = checkAuth(request) # code = 200 # user_id = 16 if code == 200: bot = Bot.query.filter_by(bot_guid=bot_guid).first() if bot: if bot.user_id == user_id: for key in redis_db.scan_iter(match=bot_guid + '_*'): redis_db.delete(key) print('training') rasa_data = { "rasa_nlu_data": { "common_examples": [{ "text": "Nomnffl", "intent": "None", "entities": [] }, { "text": "Nekdg", "intent": "None", "entities": [] }, { "text": "Fesf", "intent": "None", "entities": [] }, { "text": "this is the this", "intent": "None", "entities": [] }, { "text": "likesdike mike", "intent": "None", "entities": [] }], "entity_synonyms": [], "regex_features": [] } } intents = Intent.query.filter_by(bot_guid=bot_guid).filter( ~Intent.name.like('eliza.%')).all() entities = Entity.query.filter_by(bot_guid=bot_guid) ent_data = {} words_json = {} for entity in entities: ent_data[entity.name] = [] if type(entity.examples) == str: entity.examples = json.loads(entity.examples) for example_key in entity.examples: ent_data[entity.name].extend( entity.examples[example_key]) rasa_data['rasa_nlu_data']['entity_synonyms'].append({ "value": example_key, "synonyms": entity.examples[example_key] }) for intent in intents: for utterance in intent.utterances: utt_copy = utterance intent_name = intent.name for word in stopWords: utt_copy = utt_copy.replace(word, " ") utt_words = utt_copy.split(" ") for word in utt_words: if word in words_json: if intent_name in words_json[word]: words_json[word][intent_name] += 1 else: words_json[word][intent_name] = 1 else: words_json[word] = {intent_name: 1} terminals = [] common_example = {} common_example['text'] = utterance.lower() common_example['intent'] = intent.name common_example['entities'] = [] new_examples = [] new_values = [] for entity in entities: if type(entity.examples) == str: entity.examples = json.loads(entity.examples) for example_key in entity.examples: utterance = utterance.lower() ent_examples = entity.examples[example_key] # Used to consider key as well - but key is automatically added (not verified) when retreiving so these steps are not needed # if example_key.lower() not in ent_examples: # if example_key in ent_examples: # ent_examples.remove(example_key) # ent_examples.append(example_key.lower()) for example in ent_examples: example = example.lower() test_utterance = ' ' + utterance + ' ' test_example = ' ' + example + ' ' if test_example in test_utterance: #print("here") start = utterance.find(example) end = start + len(example) is_valid = True if len(terminals) > 0: mod_terminals = [ x for x in terminals ] for term_start, term_end, name, value in terminals: if term_start <= start and term_end >= end: is_valid = False continue if start <= term_start and end >= term_end: mod_terminals.remove( (term_start, term_end, name, value)) continue terminals = [x for x in terminals] if is_valid: terminals.append( (start, end, entity.name, example)) for terminal in terminals: common_example['entities'].append({ "start": terminal[0], "end": terminal[1], "entity": terminal[2], "value": terminal[3] }) remaining_examples = ent_data[terminal[2]] if terminal[3] in remaining_examples: remaining_examples.remove(terminal[3]) values = generate(utterance, terminal[3], remaining_examples, intent.name, entities) new_values += values rasa_data['rasa_nlu_data']['common_examples'].append( common_example) # rasa_data['rasa_nlu_data']['common_examples'] += new_values # print(type(new_values)) # print(len(new_values)) # child_count = 0 # for val in new_values: # if type(val) == dict: # child_count += 1 # print(child_count) #print(rasa_data['rasa_nlu_data']['common_examples']) job = q.enqueue(train_bot, bot, rasa_data, words_json, timeout=600) job_id = job.get_id() print(job_id) app.logger.info('GET /api/train/' + bot_guid + ' bot training started') return jsonify({"success": True, "job_id": job_id}) #train_bot(bot,rasa_data, words_json) else: app.logger.warning('GET /api/train/' + bot_guid + ' not authorized') return jsonify({"error": "Not Authorized"}), 401 else: app.logger.warning('GET /api/train/' + bot_guid + ' bot does not exist') return jsonify({"error": "Bot doesn't exist"}), 404 elif code == 400: app.logger.warning('GET /api/train/' + bot_guid + ' invalid authorization token') return jsonify({"error": "Invalid Authorization Token"}), 400 elif code == 401: app.logger.warning('GET /api/train/' + bot_guid + ' no authorization token sent') return jsonify({"error": "No Authorization Token Sent"}), 401
def entities(bot_guid): code,user_id = checkAuth(request) if code == 200: bot = Bot.query.filter_by(bot_guid=bot_guid).first() if bot: if bot.user_id == user_id: if request.method == 'GET': entities = Entity.query.filter_by(bot_guid=bot_guid) entities_obj = [] for entity in entities: if type(entity.examples) == str: entity.examples = json.loads(entity.examples) entity_obj = {} entity_obj['name'] = entity.name entity_obj['examples'] = entity.examples entity_obj['num_examples'] = len(entity.examples) entities_obj.append(entity_obj) app.logger.warning('GET /api/entities/'+bot_guid+ ' successfully returned entities') return jsonify({"entities":entities_obj}) elif request.method == 'POST': post_data = request.get_json() if not post_data: response_object = { 'status': 'fail', 'message': 'Invalid payload.' } app.logger.warning('POST /api/entities/'+bot_guid+ ' invalid post object') return jsonify(response_object), 400 else: name = post_data.get('name') examples = post_data.get('examples') entity = Entity.query.filter_by(name=name).first() if entity: entity.examples = examples else: entity = Entity( name = name.lower(), bot_guid=bot_guid, examples=examples ) db.session.add(entity) try: db.session.commit() except Exception as e: app.logger.error('POST /api/entities/'+bot_guid+ ' ' + str(e)) return jsonify({"success":False,"error":str(e)}) app.logger.info('POST /api/entities/'+bot_guid+ ' successfully returned entities') return jsonify({"success":True}) elif request.method == 'DELETE': entity_name = request.args['entity'] entity = Entity.query.filter_by(bot_guid=bot_guid).filter_by(name=entity_name).first() if entity: db.session.delete(entity) try: db.session.commit() except Exception as e: app.logger.error('DELETE /api/entities/'+bot_guid+ ' ' + str(e)) return jsonify({"success":False,"error":str(e)}) app.logger.info('DELETE /api/entities/'+bot_guid+ ' successfully deleted entity') return jsonify({"success":True}) else: app.logger.warning('DELETE /api/entities/'+bot_guid+ ' bot does not exist') return jsonify({"success":False,"error":"Entity doesn't exsit"}),404 elif code == 400: app.logger.warning('/api/entities/'+bot_guid+ ' invalid authorization token') return jsonify({"error":"Invalid Authorization Token"}),400 elif code == 401: app.logger.warning('/api/entities/'+bot_guid+ ' no authorization token sent') return jsonify({"error":"No Authorization Token Sent"}),401
def update_bots(bot_guid): code, user_id = checkAuth(request) # code = 200 # user_id = 16 if code == 200: bot = Bot.query.filter_by(bot_guid=bot_guid).first() if not bot: app.logger.warning('/api/bots/' + bot_guid + ' Bot Not Found') return jsonify({"error": "Bot Not Found"}), 404 if bot.user_id == user_id: if request.method == 'PUT': # print('here') put_data = request.get_json() if 'last_trained' in put_data and bot.last_trained != put_data[ 'last_trained']: if 'active_model' in put_data: model_directory = put_data['active_model'] config = './project/config.json' current_model = bot.active_model if current_model and current_model != "": global interpreters interpreters.pop(current_model, 0) if os.path.exists(current_model): shutil.rmtree(current_model) interpreters[model_directory] = NLUParser( model_directory, config) training_obj = Training( bot_guid=bot_guid, user_id=user_id, trained_at=put_data['last_trained'], train_time=put_data['train_time']) db.session.add(training_obj) bot.active_model = put_data['active_model'] bot.words = put_data['words'] bot.last_trained = put_data['last_trained'] bot.name = put_data['name'] bot.persona = put_data['persona'] bot.used = datetime.datetime.utcnow() try: db.session.commit() except Exception as e: app.logger.error('PUT /api/bots/' + bot_guid + ' ' + str(e)) return jsonify({'errors': str(e)}), 400 app.logger.info('PUT /api/bots/' + bot_guid + ' bot updated successfully') return jsonify({"success": True}) elif request.method == 'DELETE': try: db.session.delete(bot) db.session.commit() except Exception as e: app.logger.error('DELETE /api/bots/' + bot_guid + ' ' + str(e)) return jsonify({'errors': str(e)}), 400 bots = Bot.query.filter_by(user_id=user_id) bots_obj = [] for bot in bots: bot_obj = {} bot_obj['id'] = bot.id bot_obj['bot_guid'] = bot.bot_guid bot_obj['user_id'] = bot.user_id bot_obj['name'] = bot.name bot_obj['used'] = ( bot.used - datetime.datetime(1970, 1, 1)).total_seconds() bots_obj.append(bot_obj) app.logger.info('DELETE /api/bots/' + bot_guid + ' bot deleted successfully') return jsonify({"bots": bots_obj}) else: app.logger.warning('/api/bots/' + bot_guid + ' unauthorized') return jsonify({"error": "Unauthorized"}), 401 elif code == 400: app.logger.warning('/api/bots/' + bot_guid + ' invalid authorization token') return jsonify({"error": "Invalid Authorization Token"}), 400 elif code == 401: app.logger.warning('/api/bots/' + bot_guid + ' no authorization token sent') return jsonify({"error": "No Authorization Token Sent"}), 401
def intents(bot_guid): code,user_id = checkAuth(request) if code == 200: global interpreters nlus = interpreters bot = Bot.query.filter_by(bot_guid=bot_guid).first() base = request.args.get('base') if not base: base = '/' if bot: if bot.user_id == user_id: if request.method == 'GET': if base == '/': intents = Intent.query.filter_by(bot_guid=bot_guid) base_pattern = '/' else: base_pattern = '.'.join(base[1:].split('/')) + '.%' intents = Intent.query.filter_by(bot_guid=bot_guid).filter(Intent.name.like(base_pattern)).all() intents_obj = [] empty_folders = [] folder_list = {} for intent in intents: intent_obj = {} folders = intent.name.split('.') if len(folders) > 1: if not base_pattern == '/': folder_name = folders[len(base_pattern[:-2].split('.'))] else: folder_name = folders[0] if folders[-1] == folder_name: is_folder = intent.is_folder else: is_folder = True if not folder_name in folder_list: if base_pattern == '/': pattern = folder_name +'.%' else: pattern = base_pattern[:-1] + folder_name + '.%' contents = Intent.query.filter_by(bot_guid=bot_guid).filter_by(is_folder=False).filter(Intent.name.like(pattern)).all() folder_list[folder_name] = intent.modified intent_obj['name'] = folder_name intent_obj['is_folder'] = is_folder intent_obj['count'] = len(contents) intent_obj['utterances'] = len(intent.utterances) intent_obj['responses'] = len(intent.responses) intent_obj['patterns'] = len(intent.patterns) intent_obj['calls'] = intent.calls intent_obj['modified'] = intent.modified intents_obj.append(intent_obj) else: intent_obj['is_folder'] = intent.is_folder intent_obj['name'] = intent.name intent_obj['count'] = 0 intent_obj['utterances'] = len(intent.utterances) intent_obj['responses'] = len(intent.responses) intent_obj['patterns'] = len(intent.patterns) intent_obj['calls'] = intent.calls intent_obj['modified'] = intent.modified if not intent.is_folder: intents_obj.append(intent_obj) else: empty_folders.append(intent_obj) for folder in empty_folders: if not (folder['name'] in folder_list): intents_obj.append(folder) app.logger.info('GET /api/intents/'+bot_guid+ ' successfully returned list of intents') return jsonify({"intents":intents_obj}) elif request.method == 'POST': post_data = request.get_json() if not post_data: response_object = { 'status': 'fail', 'message': 'Invalid payload.' } return jsonify(response_object), 400 else: if base == '/': prefix = '' else: prefix = '.'.join(base[1:].split('/'))+'.' name = prefix + post_data.get('name') utterances = post_data.get('utterances') responses = post_data.get('responses') has_entities = post_data.get('has_entities') is_folder = post_data.get('is_folder') intent = Intent.query.filter_by(bot_guid=bot_guid).filter_by(name=name).filter_by(is_folder=is_folder).first() if intent: return jsonify({"success":False,"error":"An intent with that name already exists"}) else: intent = Intent( name = name, bot_guid=bot_guid, utterances=utterances, has_entities=has_entities, responses = responses, is_folder=is_folder, patterns=[] ) db.session.add(intent) try: db.session.commit() except Exception as e: app.logger.error('POST /api/intents/'+bot_guid+ ' ' + str(e)) return jsonify({"success":False,"errors":str(e)}) app.logger.info('POST /api/intents/'+bot_guid+ ' successfully added intent') return jsonify({"success":True}) elif request.method == 'PUT': put_data = request.get_json() if not put_data: response_object = { 'status': 'fail', 'message': 'Invalid payload.' } app.logger.warning('PUT /api/intents/'+bot_guid+ ' invalid put object') return jsonify(response_object), 400 else: old_name = put_data['old_name'] new_name = put_data['new_name'] if old_name[-1] == "%": intents = Intent.query.filter_by(bot_guid=bot_guid).filter(Intent.name.like(old_name)).all() for intent in intents: name = intent.name intent.name = name.replace(old_name[:-1],new_name) intent.modified = datetime.datetime.utcnow() try: db.session.commit() except Exception as e: app.logger.error('PUT /api/intents/'+bot_guid+ ' ' + str(e)) return jsonify({"success":False}) app.logger.info('PUT /api/intents/'+bot_guid+ ' successfully updated intent') return jsonify({"success":True}) else: intent = Intent.query.filter_by(bot_guid=bot_guid).filter_by(name=old_name).first() if intent: intent.name = new_name intent.modified = datetime.datetime.utcnow() try: db.session.commit() except Exception as e: app.logger.error('PUT /api/intents/'+bot_guid+ ' ' + str(e)) return jsonify({"success":False}) app.logger.info('GET /api/intents/'+bot_guid+ ' successfully updated intent') return jsonify({"success":True}) else: app.logger.warning('PUT /api/intents/'+bot_guid+ ' intent does not exist') return jsonify({"success":False,"errors":"Intent doesn't exist"}) elif request.method == 'DELETE': intent_name = request.args['intent'] if intent_name[0] == '.': intent_name = intent_name[1:] if intent_name[-1] == '%': try: query = Intent.query.filter_by(bot_guid=bot_guid).filter(Intent.name.like(intent_name)) query.delete(synchronize_session=False) db.session.commit() except Exception as e: app.logger.error('DELETE /api/intents/'+bot_guid+ ' ' + str(e)) return jsonify({"success":False,"errors":str(e)}) app.logger.info('DELETE /api/intents/'+bot_guid+ ' successfully deleted intent') return jsonify({"success":True}) else: intent = Intent.query.filter_by(bot_guid=bot_guid).filter_by(name=intent_name).first() if intent: db.session.delete(intent) try: db.session.commit() except Exception as e: app.logger.error('DELETE /api/intents/'+bot_guid+ ' ' + str(e)) return jsonify({"success":False,"errors":str(e)}) app.logger.info('DELETE /api/intents/'+bot_guid+ ' successfully deleted intent') return jsonify({"success":True}) else: app.logger.warning('DELETE /api/intents/'+bot_guid+ ' intent does not exist') return jsonify({"success":False,"errors":"intent doesn't exist"}) elif code == 400: app.logger.warning('/api/intents/'+bot_guid+ ' invalid authorization token') return jsonify({"error":"Invalid Authorization Token"}),400 elif code == 401: app.logger.warning('/api/intents/'+bot_guid+ ' no authorization token sent') return jsonify({"error":"No Authorization Token Sent"}),401
def pattern(bot_guid, intent_name): code, user_id = checkAuth(request) # code = 200 # user_id = 16 if code == 200: global interpreters nlus = interpreters bot = Bot.query.filter_by(bot_guid=bot_guid).first() if bot: if bot.user_id == user_id: intent = Intent.query.filter_by(bot_guid=bot_guid).filter_by( name=intent_name).first() if intent: model = bot.active_model if model: nlu = nlus[model] else: nlu = None if request.method == 'GET': patterns_obj = [] patterns = intent.patterns for pattern in patterns: pattern = json.loads(pattern) pat_obj = {} pat_obj["string"] = pattern['string'] pat_obj["regex"] = pattern['regex'] pat_obj["len"] = pattern['len'] pat_obj["entities"] = pattern['entities'] patterns_obj.append(pat_obj) patterns_obj = sorted(patterns_obj, key=lambda k: k['len'], reverse=True) app.logger.info( 'GET /api/intents/' + bot_guid + '/' + intent_name + '/patterns successfully returned patterns') return jsonify({"patterns": patterns_obj}) if request.method == 'POST': post_data = request.get_json() new_pattern = post_data['value'] for pattern in intent.patterns: pattern = json.loads(pattern) if new_pattern == pattern["string"]: return jsonify({"success": False}) parameters, regex = get_regex(new_pattern) new_obj = {} new_obj['string'] = new_pattern new_obj['regex'] = regex new_obj['entities'] = parameters new_obj['len'] = len(new_pattern) pats = [json.dumps(new_obj)] + intent.patterns intent.patterns = [p for p in pats] try: db.session.commit() except Exception as e: app.logger.error('POST /api/intents/' + bot_guid + '/' + intent_name + '/patterns ' + str(e)) return jsonify({ "success": False, "errors": str(e) }) app.logger.info( 'POST /api/intents/' + bot_guid + '/' + intent_name + '/patterns successfully added patterns') return jsonify({"pattern": new_obj}) elif request.method == 'PUT': put_data = request.get_json() old_pattern = put_data['old_pattern'] new_pattern = put_data['new_pattern'] parameters, regex = get_regex(new_pattern) new_patterns = [] for pattern in intent.patterns: pattern = json.loads(pattern) if pattern["string"] == old_pattern: pattern["string"] = new_pattern pattern["regex"] = regex pattern["entities"] = parameters pattern["len"] = len(new_pattern) new_patterns.append(json.dumps(pattern)) intent.patterns = new_patterns try: db.session.commit() except Exception as e: app.logger.error('PUT /api/intents/' + bot_guid + '/' + intent_name + '/patterns ' + str(e)) return jsonify({ "success": False, "errors": str(e) }) app.logger.info( 'GET /api/intents/' + bot_guid + '/' + intent_name + '/patterns successfully updated patterns') return jsonify({"success": True}) elif request.method == 'DELETE': old_pattern = request.args['pattern'] new_patterns = [] for pattern in intent.patterns: pattern = json.loads(pattern) if (pattern['string'] != old_pattern): new_patterns.append(json.dumps(pattern)) intent.patterns = new_patterns try: db.session.commit() except Exception as e: app.logger.error('DELETE /api/intents/' + bot_guid + '/' + intent_name + '/patterns ' + str(e)) return jsonify({ "success": False, "errors": str(e) }) app.logger.info( 'DELETE /api/intents/' + bot_guid + '/' + intent_name + '/patterns successfully deleted patterns') return jsonify({"success": True}) else: app.logger.warning('/api/intents/' + bot_guid + '/' + intent_name + '/patterns intent does not exist') return jsonify({"error": "Intent Doesn't exist"}), 404 else: app.logger.warning('/api/intents/' + bot_guid + '/' + intent_name + '/patterns not authorized') return jsonify({"error": "Not Authorized"}), 401 else: app.logger.warning('/api/intents/' + bot_guid + '/' + intent_name + '/patterns bot does not exist') return jsonify({"error": "Bot Doesn't exist"}), 404 elif code == 400: app.logger.warning('/api/intents/' + bot_guid + '/' + intent_name + '/patterns invalid authorization token') return jsonify({"error": "Invalid Authorization Token"}), 400 elif code == 401: app.logger.warning('/api/intents/' + bot_guid + '/' + intent_name + '/patterns no authorization token sent') return jsonify({"error": "No Authorization Token Sent"}), 401
def intent(bot_guid, intent_name): try: code, user_id = checkAuth(request) # code = 200 # user_id = 16 if code == 200: global interpreters nlus = interpreters bot = Bot.query.filter_by(bot_guid=bot_guid).first() if bot: if bot.user_id == user_id: intent = Intent.query.filter_by( bot_guid=bot_guid).filter_by(name=intent_name).first() if intent: model = bot.active_model if model: nlu = nlus[model] else: nlu = None intent.modified = datetime.datetime.utcnow() if request.method == 'POST': post_data = request.get_json() new_utterance = post_data['value'] stop_words = [" a ", " an ", " the ", " is "] utt_copy = new_utterance for word in stop_words: utt_copy = utt_copy.replace(word, " ") utt_words = utt_copy.split(" ") words_json = json.loads(bot.words) if type(words_json) == str: words_json = {} for word in utt_words: if word in words_json: if intent_name in words_json[word]: words_json[word][intent_name] += 1 else: words_json[word][intent_name] = 1 else: words_json[word] = {intent_name: 1} bot.words = json.dumps(words_json) if new_utterance in intent.utterances: app.logger.warning( 'POST /api/intents/' + bot_guid + '/' + intent_name + '/utterances utterance already exists') return jsonify({}) else: utts = [new_utterance] + intent.utterances intent.utterances = [u for u in utts] if nlu: int, entities, confidence = nlu.parse( new_utterance) else: entities = [] try: db.session.commit() except Exception as e: app.logger.error('POST /api/intents/' + bot_guid + '/' + intent_name + '/utterances ' + str(e)) return jsonify({ "success": False, "errors": str(e) }) app.logger.warning( 'POST /api/intents/' + bot_guid + '/' + intent_name + '/utterances utterance successfully added') return jsonify({ "utterance": new_utterance, "entities": entities }) elif request.method == 'PUT': put_data = request.get_json() old_utterance = put_data['old_utterance'] new_utterance = put_data['value'] intent.utterances = [ new_utterance if u == old_utterance else u for u in intent.utterances ] intent.modified = datetime.datetime.utcnow() int, entities, confidence = nlu.parse( new_utterance) try: db.session.commit() except Exception as e: app.logger.error('PUT /api/intents/' + bot_guid + '/' + intent_name + '/utterances ' + str(e)) return jsonify({ "success": False, "errors": str(e) }) app.logger.info( 'PUT /api/intents/' + bot_guid + '/' + intent_name + '/utterances utterance successfully updated') return jsonify({ "utterance": new_utterance, "entities": entities }) elif request.method == 'DELETE': old_utterance = request.args['utterance'] new_utterances = [] for utterance in intent.utterances: if (utterance != old_utterance): new_utterances.append(utterance) intent.utterances = new_utterances intent.modified = datetime.datetime.utcnow() try: db.session.commit() except Exception as e: app.logger.error('DELETE /api/intents/' + bot_guid + '/' + intent_name + '/utterances ' + str(e)) return jsonify({ "success": False, "errors": str(e) }) app.logger.info( 'DELETE /api/intents/' + bot_guid + '/' + intent_name + '/utterances utterance successfully deleted') return jsonify({"success": True}) else: app.logger.warning('/api/intents/' + bot_guid + '/' + intent_name + '/utterances intent does not exist') return jsonify({"error": "Intent Doesn't exist"}), 404 elif code == 400: app.logger.warning('/api/intents/' + bot_guid + '/' + intent_name + '/utterances invalid authorization token') return jsonify({"error": "Invalid Authorization Token"}), 400 elif code == 401: app.logger.warning('/api/intents/' + bot_guid + '/' + intent_name + '/utterances no authorization token sent') return jsonify({"error": "No Authorization Token Sent"}), 401 except Exception as e: app.logger.warning('/api/intents/' + bot_guid + '/' + intent_name + '/utterances ' + str(e)) return jsonify({'success': False, 'errors': str(e)}), 400
def response(bot_guid, intent_name): code, user_id = checkAuth(request) # code = 200 # user_id = 16 if code == 200: global interpreters nlus = interpreters bot = Bot.query.filter_by(bot_guid=bot_guid).first() if bot: if bot.user_id == user_id: intent = Intent.query.filter_by(bot_guid=bot_guid).filter_by( name=intent_name).first() if intent: intent.modified = datetime.datetime.utcnow() if request.method == 'POST': post_data = request.get_json() new_response = post_data['value'] if new_response in intent.responses: return jsonify({}) else: resps = [new_response] + intent.responses intent.responses = [r for r in resps] try: db.session.commit() except Exception as e: app.logger.error('POST /api/intents/' + bot_guid + '/' + intent_name + '/responses ' + str(e)) return jsonify({ "success": False, "errors": str(e) }) app.logger.info( 'POST /api/intents/' + bot_guid + '/' + intent_name + '/responses successfully added response') return jsonify({"success": True}) elif request.method == 'PUT': put_data = request.get_json() old_response = put_data['old_response'] new_response = put_data['value'] intent.responses = [ new_response if u == old_response else u for u in intent.responses ] try: db.session.commit() except Exception as e: app.logger.error('PUT /api/intents/' + bot_guid + '/' + intent_name + '/responses ' + str(e)) return jsonify({ "success": False, "errors": str(e) }) app.logger.info( 'PUT /api/intents/' + bot_guid + '/' + intent_name + '/responses successfully updated response') return jsonify({"success": True}) elif request.method == 'DELETE': old_response = request.args['response'] new_responses = [] for response in intent.responses: if (response != old_response): new_responses.append(response) intent.responses = new_responses try: db.session.commit() except Exception as e: app.logger.error('DELETE /api/intents/' + bot_guid + '/' + intent_name + '/responses ' + str(e)) return jsonify({ "success": False, "errors": str(e) }) app.logger.info( 'DELETE /api/intents/' + bot_guid + '/' + intent_name + '/responses successfully deleted response') return jsonify({"success": True}) else: app.logger.warning('/api/intents/' + bot_guid + '/' + intent_name + '/responses intent does not exist') return jsonify({"error": "Intent Doesn't exist"}), 404 elif code == 400: app.logger.warning('/api/intents/' + bot_guid + '/' + intent_name + '/responses invalid authorization token') return jsonify({"error": "Invalid Authorization Token"}), 400 elif code == 401: app.logger.warning('/api/intents/' + bot_guid + '/' + intent_name + '/responses no authorization token sent') return jsonify({"error": "No Authorization Token Sent"}), 401