async def train(
background_tasks: BackgroundTasks,
current_user: User = Depends(auth.get_current_user),
):
""" This is used to train the chatbot """
ModelProcessor.is_training_inprogress(current_user.get_bot())
ModelProcessor.is_daily_training_limit_exceeded(current_user.get_bot())
background_tasks.add_task(start_training, current_user.get_bot(),
current_user.get_user())
return {"message": "Model training started."}
async def set_endpoint(background_tasks: BackgroundTasks,
endpoint: Endpoint,
current_user: User = Depends(auth.get_current_user)):
"""get the bot config"""
mongo_processor.add_endpoints(endpoint.dict(), current_user.get_bot(),
current_user.get_user())
if endpoint.action_endpoint:
background_tasks.add_task(AgentProcessor.reload,
current_user.get_bot())
return {"message": "Endpoint saved successfully!"}
async def get_responses(utterance: str,
current_user: User = Depends(auth.get_current_user)):
""" This function returns the list of responses for a particular utterance of the bot """
return {
"data":
list(mongo_processor.get_response(utterance, current_user.get_bot()))
}
async def search_intent(request_data: TextData,
current_user: User = Depends(auth.get_current_user)):
""" This function returns the search intent of the entered text by using mongo text search"""
search_items = list(
mongo_processor.search_training_examples(request_data.data,
current_user.get_bot()))
return {"data": {"searched_items": search_items}}
async def add_intents(request_data: TextData,
current_user: User = Depends(auth.get_current_user)):
""" This function is used to add a new intent to the bot """
id = mongo_processor.add_intent(text=request_data.data.strip(),
bot=current_user.get_bot(),
user=current_user.get_user())
return {"message": "Intent added successfully!", "data": {"_id": id}}
async def chat_history_users(current_user: User = Depends(
auth.get_current_user)):
return {
"data": {
"users": ChatHistory.fetch_chat_users(current_user.get_bot())
}
}
async def set_endpoint(
endpoint: Endpoint,
current_user: User = Depends(auth.get_current_user),
):
"""get the bot config"""
mongo_processor.add_endpoints(endpoint.dict(), current_user.get_bot(),
current_user.get_user())
return {"message": "Endpoint saved successfully!"}
async def chat_history_users(current_user: User = Depends(
auth.get_current_user)):
""" This function returns the list of the chatbot users """
return {
"data": {
"users": ChatHistory.fetch_chat_users(current_user.get_bot())
}
}
async def get_config(current_user: User = Depends(auth.get_current_user), ):
"""
fetch bot pipeline and polcies configurations
:param current_user: user id
:return: dict of configurations
"""
config = mongo_processor.load_config(current_user.get_bot())
return {"data": {"config": config}}
async def chat(request_data: TextData,
current_user: User = Depends(auth.get_current_user)):
""" This function returns a bot response for a given text/query. It is basically
used to test the chat functionality of the bot """
model = AgentProcessor.get_agent(current_user.get_bot())
response = await model.handle_text(request_data.data,
sender_id=current_user.get_user())
return {"data": {"response": response[0]["text"] if response else None}}
async def reload_model(background_tasks: BackgroundTasks,
current_user: User = Depends(auth.get_current_user)):
"""
reload model with configuration in cache
:param current_user: user id
:return: Model reloaded!
"""
background_tasks.add_task(AgentProcessor.reload, current_user.get_bot())
return {"message": "Reloading Model!"}
async def chat_history(sender: Text,
current_user: User = Depends(auth.get_current_user)):
return {
"data": {
"history":
list(ChatHistory.fetch_chat_history(current_user.get_bot(),
sender))
}
}
async def get_story_from_intent(intent: str,
current_user: User = Depends(
auth.get_current_user)):
""" This function returns the utterance or response that is mapped to a particular intent """
return {
"data":
mongo_processor.get_utterance_from_intent(intent,
current_user.get_bot())
}
async def set_config(
config: Config,
current_user: User = Depends(auth.get_current_user),
):
"""set the bot config"""
endpoint = mongo_processor.save_config(config.dict(),
current_user.get_bot(),
current_user.get_user())
return {"data": {"config": endpoint}}
async def predict_intent(request_data: TextData,
current_user: User = Depends(auth.get_current_user)):
""" This function returns the predicted intent of the entered text by using the trained
rasa model of the chatbot """
model = AgentProcessor.get_agent(current_user.get_bot())
response = await model.parse_message_using_nlu_interpreter(
request_data.data)
intent = response.get("intent").get("name") if response else None
confidence = response.get("intent").get("confidence") if response else None
return {"data": {"intent": intent, "confidence": confidence}}
async def chat_history(sender: Text,
current_user: User = Depends(auth.get_current_user)):
""" This function returns the chat history for a particular user of the chatbot """
return {
"data": {
"history":
list(ChatHistory.fetch_chat_history(current_user.get_bot(),
sender))
}
}
async def get_training_examples(intent: str,
current_user: User = Depends(
auth.get_current_user)):
""" This function is used to return the training examples (questions/sentences)
which are used to train the chatbot, for a particular intent """
return {
"data":
list(
mongo_processor.get_training_examples(intent,
current_user.get_bot()))
}
async def deployment_history(current_user: User = Depends(
auth.get_current_user)):
""" This function is used to deploy the model of the currently trained chatbot """
return {
"data": {
"deployment_history":
list(
mongo_processor.get_model_deployment_history(
bot=current_user.get_bot()))
}
}
async def add_responses(
request_data: TextData,
utterance: str,
current_user: User = Depends(auth.get_current_user),
):
""" This function adds a response to the list of responses for a particular utterance
of the bot """
id = mongo_processor.add_text_response(request_data.data, utterance,
current_user.get_bot(),
current_user.get_user())
return {"message": "Response added successfully!", "data": {"_id": id}}
async def remove_responses(request_data: TextData,
current_user: User = Depends(
auth.get_current_user)):
""" This function removes the bot response from the response list for a particular
utterance """
mongo_processor.remove_document(Responses, request_data.data,
current_user.get_bot(),
current_user.get_user())
return {
"message": "Response removed successfully!",
}
async def set_config_template(request_data: TextData,
current_user: User = Depends(
auth.get_current_user)):
"""
apply the config template
:param request_data: config template name
:param current_user: user id
:return: Config Applied!
"""
mongo_processor.apply_config(request_data.data, current_user.get_bot(),
current_user.get_user())
return {"message": "Config applied!"}
async def get_responses(utterance: str,
current_user: User = Depends(auth.get_current_user)):
"""
fetch list of utterances against utterance name
:param utterance: utterance name
:param current_user: loggedin user id
:return: list of utterances
"""
return {
"data":
list(mongo_processor.get_response(utterance, current_user.get_bot()))
}
async def remove_training_examples(request_data: TextData,
current_user: User = Depends(
auth.get_current_user)):
""" This function is used to delete a particular training example (question/sentence) from a list
of examples for a particular intent """
mongo_processor.remove_document(
TrainingExamples,
request_data.data,
current_user.get_bot(),
current_user.get_user(),
)
return {"message": "Training Example removed successfully!"}
async def add_training_examples(
intent: str,
request_data: ListData,
current_user: User = Depends(auth.get_current_user),
):
""" This is used to add a new training example (sentence/question) for a
particular intent """
results = list(
mongo_processor.add_training_example(request_data.data, intent,
current_user.get_bot(),
current_user.get_user()))
return {"data": results}
async def set_config(
config: Config,
current_user: User = Depends(auth.get_current_user),
):
"""
save the bot pipeline and policies configurations
:param config: configuration
:param current_user: user id
:return: Config saved!
"""
mongo_processor.save_config(config.dict(), current_user.get_bot(),
current_user.get_user())
return {"message": "Config saved!"}
async def upload_Files(
background_tasks: BackgroundTasks,
nlu: UploadFile = File(...),
domain: UploadFile = File(...),
stories: UploadFile = File(...),
config: UploadFile = File(...),
overwrite: bool = True,
current_user: User = Depends(auth.get_current_user),
):
"""Upload training data nlu.md, domain.yml, stories.md and config.yml files"""
await mongo_processor.upload_and_save(
await nlu.read(),
await domain.read(),
await stories.read(),
await config.read(),
current_user.get_bot(),
current_user.get_user(),
overwrite,
)
background_tasks.add_task(start_training, current_user.get_bot(),
current_user.get_user())
return {"message": "Data uploaded successfully!"}
async def get_templates(request_data: TextData,
current_user: User = Depends(auth.get_current_user)):
"""
apply the use-case template
:param request_data: use-case name
:param current_user: user id
:return: Data applied!
:exception: Invalid template
"""
await mongo_processor.apply_template(request_data.data,
bot=current_user.get_bot(),
user=current_user.get_user())
return {"message": "Data applied!"}
async def download_data(
background_tasks: BackgroundTasks,
current_user: User = Depends(auth.get_current_user),
):
"""Download training data nlu.md, domain.yml, stories.md, config.yml files"""
file = mongo_processor.download_files(current_user.get_bot())
response = FileResponse(file,
filename=os.path.basename(file),
background=background_tasks)
response.headers[
"Content-Disposition"] = "attachment; filename=" + os.path.basename(
file)
return response
async def delete_intent(intent: str,
current_user: User = Depends(auth.get_current_user)):
"""
This function will be utilized to delete an intent and
its dependencies with TrainingExamples and Stories
"""
intentName = mongo_processor.deleteIntentWithDependencies(
intent, current_user.get_bot(), current_user.get_user())
return {
"message": "Intent successfully deleted!",
"data": {
"IntentName": intentName
}
}
async def add_stories(story: StoryRequest,
current_user: User = Depends(auth.get_current_user)):
""" This function is used to add a story (conversational flow) to the chatbot """
return {
"message": "Story added successfully",
"data": {
"_id":
mongo_processor.add_story(
story.name,
story.get_events(),
current_user.get_bot(),
current_user.get_user(),
)
},
}
