def test_facebook_channel():
# START DOC INCLUDE
from rasa.core.channels.facebook import FacebookInput
from rasa.core.agent import Agent
from rasa.core.interpreter import RegexInterpreter
# load your trained agent
agent = Agent.load(MODEL_PATH, interpreter=RegexInterpreter())
input_channel = FacebookInput(
fb_verify="YOUR_FB_VERIFY",
# you need tell facebook this token, to confirm your URL
fb_secret="YOUR_FB_SECRET", # your app secret
fb_access_token="YOUR_FB_PAGE_ACCESS_TOKEN"
# token for the page you subscribed to
)
s = agent.handle_channels([input_channel], 5004)
# END DOC INCLUDE
# the above marker marks the end of the code snipped included
# in the docs
routes_list = utils.list_routes(s)
assert routes_list.get("fb_webhook.health").startswith(
"/webhooks/facebook")
assert routes_list.get("fb_webhook.webhook").startswith(
"/webhooks/facebook/webhook")
def test_webexteams_channel():
# START DOC INCLUDE
from rasa.core.channels.webexteams import WebexTeamsInput
from rasa.core.agent import Agent
from rasa.core.interpreter import RegexInterpreter
# load your trained agent
agent = Agent.load(MODEL_PATH, interpreter=RegexInterpreter())
input_channel = WebexTeamsInput(
access_token="YOUR_ACCESS_TOKEN",
# this is the `bot access token`
room="YOUR_WEBEX_ROOM"
# the name of your channel to which the bot posts (optional)
)
s = agent.handle_channels([input_channel], 5004)
# END DOC INCLUDE
# the above marker marks the end of the code snipped included
# in the docs
routes_list = utils.list_routes(s)
assert routes_list.get("webexteams_webhook.health").startswith(
"/webhooks/webexteams")
assert routes_list.get("webexteams_webhook.webhook").startswith(
"/webhooks/webexteams/webhook")
def test_socketio_channel():
with mock.patch.object(sanic.Sanic, "run", fake_sanic_run):
# START DOC INCLUDE
from rasa.core.channels.socketio import SocketIOInput
from rasa.core.agent import Agent
from rasa.core.interpreter import RegexInterpreter
# load your trained agent
agent = Agent.load(MODEL_PATH, interpreter=RegexInterpreter())
input_channel = SocketIOInput(
# event name for messages sent from the user
user_message_evt="user_uttered",
# event name for messages sent from the bot
bot_message_evt="bot_uttered",
# socket.io namespace to use for the messages
namespace=None,
)
s = agent.handle_channels([input_channel], 5004)
# END DOC INCLUDE
# the above marker marks the end of the code snipped included
# in the docs
routes_list = utils.list_routes(s)
assert routes_list.get("socketio_webhook.health").startswith(
"/webhooks/socketio"
)
assert routes_list.get("handle_request").startswith("/socket.io")
async def _core_model_for_finetuning(
model_to_finetune: Text,
file_importer: TrainingDataImporter,
finetuning_epoch_fraction: float = 1.0,
) -> Optional[Agent]:
path_to_archive = model.get_model_for_finetuning(model_to_finetune)
if not path_to_archive:
return None
rasa.shared.utils.cli.print_info(
f"Loading Core model from {path_to_archive} for finetuning...",
)
with model.unpack_model(path_to_archive) as unpacked:
new_fingerprint = await model.model_fingerprint(file_importer)
old_fingerprint = model.fingerprint_from_path(unpacked)
if not model.can_finetune(old_fingerprint, new_fingerprint, core=True):
rasa.shared.utils.cli.print_error_and_exit(
"Core model can not be finetuned."
)
config = await file_importer.get_config()
agent = Agent.load(
unpacked,
new_config=config,
finetuning_epoch_fraction=finetuning_epoch_fraction,
)
# Agent might be empty if no underlying Core model was found.
if agent.domain is not None and agent.policy_ensemble is not None:
return agent
return None
def test_twilio_channel():
with mock.patch.object(sanic.Sanic, "run", fake_sanic_run):
# START DOC INCLUDE
from rasa.core.channels.twilio import TwilioInput
from rasa.core.agent import Agent
from rasa.core.interpreter import RegexInterpreter
# load your trained agent
agent = Agent.load(MODEL_PATH, interpreter=RegexInterpreter())
input_channel = TwilioInput(
# you get this from your twilio account
account_sid="YOUR_ACCOUNT_SID",
# also from your twilio account
auth_token="YOUR_AUTH_TOKEN",
# a number associated with your twilio account
twilio_number="YOUR_TWILIO_NUMBER",
)
s = agent.handle_channels([input_channel], 5004)
# END DOC INCLUDE
# the above marker marks the end of the code snipped included
# in the docs
routes_list = utils.list_routes(s)
assert routes_list.get("twilio_webhook.health").startswith("/webhooks/twilio")
assert routes_list.get("twilio_webhook.message").startswith(
"/webhooks/twilio/webhook"
)
def test_callback_channel():
with mock.patch.object(sanic.Sanic, "run", fake_sanic_run):
# START DOC INCLUDE
from rasa.core.channels.callback import CallbackInput
from rasa.core.agent import Agent
from rasa.core.interpreter import RegexInterpreter
# load your trained agent
agent = Agent.load(MODEL_PATH, interpreter=RegexInterpreter())
input_channel = CallbackInput(
# URL Core will call to send the bot responses
endpoint=EndpointConfig("http://localhost:5004")
)
s = agent.handle_channels([input_channel], 5004)
# END DOC INCLUDE
# the above marker marks the end of the code snipped included
# in the docs
routes_list = utils.list_routes(s)
assert routes_list.get("callback_webhook.health").startswith(
"/webhooks/callback"
)
assert routes_list.get("callback_webhook.webhook").startswith(
"/webhooks/callback/webhook"
)
def test_botframework_channel():
with mock.patch.object(sanic.Sanic, "run", fake_sanic_run):
# START DOC INCLUDE
from rasa.core.channels.botframework import BotFrameworkInput
from rasa.core.agent import Agent
from rasa.core.interpreter import RegexInterpreter
# load your trained agent
agent = Agent.load(MODEL_PATH, interpreter=RegexInterpreter())
input_channel = BotFrameworkInput(
# you get this from your Bot Framework account
app_id="MICROSOFT_APP_ID",
# also from your Bot Framework account
app_password="******",
)
s = agent.handle_channels([input_channel], 5004)
# END DOC INCLUDE
# the above marker marks the end of the code snipped included
# in the docs
routes_list = utils.list_routes(s)
assert routes_list.get("botframework_webhook.health").startswith(
"/webhooks/botframework"
)
assert routes_list.get("botframework_webhook.webhook").startswith(
"/webhooks/botframework/webhook"
)
def test_rocketchat_channel():
with mock.patch.object(sanic.Sanic, "run", fake_sanic_run):
# START DOC INCLUDE
from rasa.core.channels.rocketchat import RocketChatInput
from rasa.core.agent import Agent
from rasa.core.interpreter import RegexInterpreter
# load your trained agent
agent = Agent.load(MODEL_PATH, interpreter=RegexInterpreter())
input_channel = RocketChatInput(
# your bots rocket chat user name
user="******",
# the password for your rocket chat bots account
password="******",
# url where your rocket chat instance is running
server_url="https://demo.rocket.chat",
)
s = agent.handle_channels([input_channel], 5004)
# END DOC INCLUDE
# the above marker marks the end of the code snipped included
# in the docs
routes_list = utils.list_routes(s)
assert routes_list.get("rocketchat_webhook.health").startswith(
"/webhooks/rocketchat"
)
assert routes_list.get("rocketchat_webhook.webhook").startswith(
"/webhooks/rocketchat/webhook"
)
async def compare(models: Text, stories_file: Text, output: Text) -> None:
"""Evaluates multiple trained models on a test set."""
from rasa.core.agent import Agent
import rasa.nlu.utils as nlu_utils
from rasa.core import utils
num_correct = defaultdict(list)
for run in nlu_utils.list_subdirectories(models):
num_correct_run = defaultdict(list)
for model in sorted(nlu_utils.list_subdirectories(run)):
logger.info("Evaluating model {}".format(model))
agent = Agent.load(model)
completed_trackers = await _generate_trackers(stories_file, agent)
story_eval_store, no_of_stories = collect_story_predictions(
completed_trackers, agent)
failed_stories = story_eval_store.failed_stories
policy_name = "".join(
[i for i in os.path.basename(model) if not i.isdigit()])
num_correct_run[policy_name].append(no_of_stories -
len(failed_stories))
for k, v in num_correct_run.items():
num_correct[k].append(v)
utils.dump_obj_as_json_to_file(os.path.join(output, "results.json"),
num_correct)
def test_mattermost_channel():
with mock.patch.object(sanic.Sanic, "run", fake_sanic_run):
# START DOC INCLUDE
from rasa.core.channels.mattermost import MattermostInput
from rasa.core.agent import Agent
from rasa.core.interpreter import RegexInterpreter
# load your trained agent
agent = Agent.load(MODEL_PATH, interpreter=RegexInterpreter())
input_channel = MattermostInput(
# this is the url of the api for your mattermost instance
url="http://chat.example.com/api/v4",
# the name of your team for mattermost
team="community",
# the username of your bot user that will post
user="******",
# messages
pw="password"
# the password of your bot user that will post messages
)
s = agent.handle_channels([input_channel], 5004)
# END DOC INCLUDE
# the above marker marks the end of the code snipped included
# in the docs
routes_list = utils.list_routes(s)
assert routes_list.get("mattermost_webhook.health").startswith(
"/webhooks/mattermost"
)
assert routes_list.get("mattermost_webhook.webhook").startswith(
"/webhooks/mattermost/webhook"
)
def load_mod(lang):
from rasa.core.agent import Agent, load_agent
# from rasa.nlu.model import Interpreter
path = f'{prefix}/models/{lang}_current.tar.gz'
# interpreter = Interpreter.load(path)
agent = Agent.load(path)
return agent
def test_telegram_channel():
# telegram channel will try to set a webhook, so we need to mock the api
with mock.patch.object(sanic.Sanic, 'run', fake_sanic_run):
httpretty.register_uri(
httpretty.POST,
'https://api.telegram.org/bot123:YOUR_ACCESS_TOKEN/setWebhook',
body='{"ok": true, "result": {}}')
httpretty.enable()
# START DOC INCLUDE
from rasa.core.channels.telegram import TelegramInput
from rasa.core.agent import Agent
from rasa.core.interpreter import RegexInterpreter
# load your trained agent
agent = Agent.load(MODEL_PATH, interpreter=RegexInterpreter())
input_channel = TelegramInput(
# you get this when setting up a bot
access_token="123:YOUR_ACCESS_TOKEN",
# this is your bots username
verify="YOUR_TELEGRAM_BOT",
# the url your bot should listen for messages
webhook_url="YOUR_WEBHOOK_URL")
s = agent.handle_channels([input_channel], 5004)
# END DOC INCLUDE
# the above marker marks the end of the code snipped included
# in the docs
routes_list = utils.list_routes(s)
assert routes_list.get("telegram_webhook.health").startswith(
"/webhooks/telegram")
assert routes_list.get("telegram_webhook.message").startswith(
"/webhooks/telegram/webhook")
httpretty.disable()
async def load_agent_on_start(core_model, endpoints, nlu_model, app, loop):
"""Load an agent.
Used to be scheduled on server start
(hence the `app` and `loop` arguments)."""
from rasa.core import broker
from rasa.core.agent import Agent
_interpreter = NaturalLanguageInterpreter.create(nlu_model, endpoints.nlu)
_broker = broker.from_endpoint_config(endpoints.event_broker)
_tracker_store = TrackerStore.find_tracker_store(None,
endpoints.tracker_store,
_broker)
if endpoints and endpoints.model:
from rasa.core import agent
app.agent = Agent(interpreter=_interpreter,
generator=endpoints.nlg,
tracker_store=_tracker_store,
action_endpoint=endpoints.action)
await agent.load_from_server(app.agent, model_server=endpoints.model)
else:
app.agent = Agent.load(core_model,
interpreter=_interpreter,
generator=endpoints.nlg,
tracker_store=_tracker_store,
action_endpoint=endpoints.action)
return app.agent
async def test_interpreter_passed_to_agent(
monkeypatch: MonkeyPatch, trained_rasa_model: Text
):
from rasa.core.interpreter import RasaNLUInterpreter
agent = Agent.load(trained_rasa_model)
assert isinstance(agent.interpreter, RasaNLUInterpreter)
def test_slack_channel():
# START DOC INCLUDE
from rasa.core.channels.slack import SlackInput
from rasa.core.agent import Agent
from rasa.core.interpreter import RegexInterpreter
# load your trained agent
agent = Agent.load(MODEL_PATH, interpreter=RegexInterpreter())
input_channel = SlackInput(
slack_token="YOUR_SLACK_TOKEN",
# this is the `bot_user_o_auth_access_token`
slack_channel="YOUR_SLACK_CHANNEL"
# the name of your channel to which the bot posts (optional)
)
s = agent.handle_channels([input_channel], 5004)
# END DOC INCLUDE
# the above marker marks the end of the code snipped included
# in the docs
routes_list = utils.list_routes(s)
assert routes_list.get("slack_webhook.health").startswith(
"/webhooks/slack")
assert routes_list.get("slack_webhook.webhook").startswith(
"/webhooks/slack/webhook")
def test_single_state_featurizer_with_interpreter_state_with_no_action_name(
unpacked_trained_moodbot_path: Text,
):
# check that action name features are not added by the featurizer when not
# present in the state and
# check user input is ignored when action is not action_listen
# and action_name is features are not added
from rasa.core.agent import Agent
interpreter = Agent.load(unpacked_trained_moodbot_path).interpreter
f = SingleStateFeaturizer()
f._default_feature_states[INTENT] = {"a": 0, "b": 1}
f._default_feature_states[ENTITIES] = {"c": 0}
f._default_feature_states[ACTION_NAME] = {"e": 0, "d": 1, "action_listen": 2}
f._default_feature_states[SLOTS] = {"e_0": 0, "f_0": 1, "g_0": 2}
f._default_feature_states[ACTIVE_LOOP] = {"h": 0, "i": 1, "j": 2, "k": 3}
encoded = f.encode_state(
{
"user": {"text": "a ball", "intent": "b", "entities": ["c"]},
"prev_action": {"action_text": "throw a ball"},
"active_loop": {"name": "k"},
"slots": {"e": (1.0,)},
},
interpreter=interpreter,
)
assert list(encoded.keys()) == [ACTION_TEXT, ACTIVE_LOOP, SLOTS]
assert encoded[ACTION_TEXT][0].features.shape[-1] == 300
assert (encoded[SLOTS][0].features != scipy.sparse.coo_matrix([[1, 0, 0]])).nnz == 0
assert (
encoded[ACTIVE_LOOP][0].features != scipy.sparse.coo_matrix([[0, 0, 0, 1]])
).nnz == 0
def test_single_state_featurizer_with_interpreter_state_with_action_listen(
unpacked_trained_spacybot_path: Text,
):
interpreter = Agent.load(unpacked_trained_spacybot_path).interpreter
f = SingleStateFeaturizer()
f._default_feature_states[INTENT] = {"greet": 0, "inform": 1}
f._default_feature_states[ENTITIES] = {
"city": 0,
"name": 1,
f"city{ENTITY_LABEL_SEPARATOR}to": 2,
f"city{ENTITY_LABEL_SEPARATOR}from": 3,
}
f._default_feature_states[ACTION_NAME] = {
"utter_ask_where_to": 0,
"utter_greet": 1,
"action_listen": 2,
}
# `_0` in slots represent feature dimension
f._default_feature_states[SLOTS] = {"slot_1_0": 0, "slot_2_0": 1, "slot_3_0": 2}
f._default_feature_states[ACTIVE_LOOP] = {
"active_loop_1": 0,
"active_loop_2": 1,
"active_loop_3": 2,
"active_loop_4": 3,
}
encoded = f.encode_state(
{
"user": {
"text": "I am flying from London to Paris",
"intent": "inform",
"entities": ["city", f"city{ENTITY_LABEL_SEPARATOR}to"],
},
"prev_action": {
"action_name": "action_listen",
"action_text": "throw a ball",
},
"active_loop": {"name": "active_loop_4"},
"slots": {"slot_1": (1.0,)},
},
interpreter=interpreter,
)
# check all the features are encoded and *_text features are encoded by a
# dense featurizer
assert sorted(list(encoded.keys())) == sorted(
[TEXT, ENTITIES, ACTION_NAME, SLOTS, ACTIVE_LOOP, INTENT, ACTION_TEXT]
)
assert encoded[TEXT][0].features.shape[-1] == 300
assert encoded[ACTION_TEXT][0].features.shape[-1] == 300
assert (encoded[INTENT][0].features != scipy.sparse.coo_matrix([[0, 1]])).nnz == 0
assert (
encoded[ACTION_NAME][0].features != scipy.sparse.coo_matrix([[0, 0, 1]])
).nnz == 0
assert encoded[ENTITIES][0].features.shape[-1] == 4
assert (encoded[SLOTS][0].features != scipy.sparse.coo_matrix([[1, 0, 0]])).nnz == 0
assert (
encoded[ACTIVE_LOOP][0].features != scipy.sparse.coo_matrix([[0, 0, 0, 1]])
).nnz == 0
async def test_end_to_end_evaluation_script(restaurantbot: Text):
restaurantbot = Agent.load(restaurantbot)
completed_trackers = await _generate_trackers(
END_TO_END_STORY_FILE, restaurantbot, use_e2e=True
)
story_evaluation, num_stories = collect_story_predictions(
completed_trackers, restaurantbot, use_e2e=True
)
serialised_store = [
"utter_ask_howcanhelp",
"action_listen",
"utter_ask_howcanhelp",
"action_listen",
"utter_on_it",
"utter_ask_cuisine",
"action_listen",
"utter_ask_numpeople",
"action_listen",
"utter_ask_howcanhelp",
"action_listen",
"utter_on_it",
"utter_ask_numpeople",
"action_listen",
"utter_ask_moreupdates",
"action_listen",
"utter_ask_moreupdates",
"action_listen",
"utter_ack_dosearch",
"action_search_restaurants",
"action_suggest",
"action_listen",
"utter_ask_howcanhelp",
"action_listen",
"greet",
"greet",
"inform",
"inform",
"greet",
"inform",
"inform",
"inform",
"deny",
"greet",
"[moderately](price:moderate)",
"[east](location)",
"[french](cuisine)",
"[cheap](price:lo)",
"[french](cuisine)",
"[bombay](location)",
"[six](people:6)",
"[moderately](price:moderate)",
]
assert story_evaluation.evaluation_store.serialise()[0] == serialised_store
assert not story_evaluation.evaluation_store.has_prediction_target_mismatch()
assert len(story_evaluation.failed_stories) == 0
assert num_stories == 4
def main():
from rasa.core.agent import Agent
from rasa.core.interpreter import NaturalLanguageInterpreter
from rasa.core.utils import AvailableEndpoints, set_default_subparser
import rasa.nlu.utils as nlu_utils
import rasa.core.cli
from rasa.core import utils
loop = asyncio.get_event_loop()
# Running as standalone python application
arg_parser = create_argument_parser()
set_default_subparser(arg_parser, "default")
cmdline_arguments = arg_parser.parse_args()
logging.basicConfig(level=cmdline_arguments.loglevel)
_endpoints = AvailableEndpoints.read_endpoints(cmdline_arguments.endpoints)
if cmdline_arguments.output:
nlu_utils.create_dir(cmdline_arguments.output)
if not cmdline_arguments.core:
raise ValueError(
"you must provide a core model directory to evaluate using -d / --core"
)
if cmdline_arguments.mode == "default":
_interpreter = NaturalLanguageInterpreter.create(
cmdline_arguments.nlu, _endpoints.nlu
)
_agent = Agent.load(cmdline_arguments.core, interpreter=_interpreter)
stories = loop.run_until_complete(
rasa.core.cli.train.stories_from_cli_args(cmdline_arguments)
)
loop.run_until_complete(
test(
stories,
_agent,
cmdline_arguments.max_stories,
cmdline_arguments.output,
cmdline_arguments.fail_on_prediction_errors,
cmdline_arguments.e2e,
)
)
elif cmdline_arguments.mode == "compare":
compare(
cmdline_arguments.core, cmdline_arguments.stories, cmdline_arguments.output
)
story_n_path = os.path.join(cmdline_arguments.core, "num_stories.json")
number_of_stories = utils.read_json_file(story_n_path)
plot_curve(cmdline_arguments.output, number_of_stories)
logger.info("Finished evaluation")
async def load_agent(bot: Text, conf: BotsConf) -> Agent:
# train it
await train_agent(bot, conf)
# load it
bot_loc = get_latest_model(f"{conf.get_loc(bot)}/models")
print(f'.. load bot model {bot_loc}')
agent = Agent.load(bot_loc, action_endpoint=conf.get_endpoint(bot))
return agent
def Load_model():
from rasa.utils.endpoints import EndpointConfig
#加载Rasa Nlu模型和Rasa Core模型
# agent = Agent.load("models/core",
# interpreter=RasaNLUInterpreter("models/nlu"))
agent = Agent.load(model_path="./models",
action_endpoint=EndpointConfig(url="http://localhost:5055/webhook"))
return agent
def run_weather_bot(serve_forever=True):
interpreter = RasaNLUInterpreter('./models/nlu/default/weathernlu')
agent = Agent.load('./models/dialogue', interpreter=interpreter)
if serve_forever:
agent.handle_channel(ConsoleInputChannel())
return agent
def run(serve_forever=True):
interpreter = RasaNLUInterpreter("models/nlu")
agent = Agent.load("models/dialogue", interpreter=interpreter)
action_endpoint = EndpointConfig(url="http://localhost:5055/webhook")
if serve_forever:
agent.handle_channels([CmdlineInput()])
return agent
def run_dialogue(serve_forever=True):
interpreter = RasaNLUInterpreter('./models/nlu/chatter')
action_endpoint = EndpointConfig(url="http://localhost:5055/webhook")
agent = Agent.load('./models/dialogue',
interpreter=interpreter,
action_endpoint=action_endpoint)
rasa.core.run.serve_application(agent, channel='cmdline')
return agent
def test_core(
model: Optional[Text] = None,
stories: Optional[Text] = None,
output: Text = DEFAULT_RESULTS_PATH,
additional_arguments: Optional[Dict] = None,
use_conversation_test_files: bool = False,
) -> None:
"""Tests a trained Core model against a set of test stories."""
import rasa.model
from rasa.shared.nlu.interpreter import RegexInterpreter
from rasa.core.agent import Agent
if additional_arguments is None:
additional_arguments = {}
if output:
rasa.shared.utils.io.create_directory(output)
try:
unpacked_model = rasa.model.get_model(model)
except ModelNotFound:
rasa.shared.utils.cli.print_error(
"Unable to test: could not find a model. Use 'rasa train' to train a "
"Rasa model and provide it via the '--model' argument."
)
return
_agent = Agent.load(unpacked_model)
if _agent.policy_ensemble is None:
rasa.shared.utils.cli.print_error(
"Unable to test: could not find a Core model. Use 'rasa train' to train a "
"Rasa model and provide it via the '--model' argument."
)
if isinstance(_agent.interpreter, RegexInterpreter):
rasa.shared.utils.cli.print_warning(
"No NLU model found. Using default 'RegexInterpreter' for end-to-end "
"evaluation. If you added actual user messages to your test stories "
"this will likely lead to the tests failing. In that case, you need "
"to train a NLU model first, e.g. using `rasa train`."
)
from rasa.core.test import test as core_test
kwargs = rasa.shared.utils.common.minimal_kwargs(
additional_arguments, core_test, ["stories", "agent", "e2e"]
)
rasa.utils.common.run_in_loop(
core_test(
stories,
_agent,
e2e=use_conversation_test_files,
out_directory=output,
**kwargs,
)
)
def test_core(
model: Optional[Text] = None,
stories: Optional[Text] = None,
endpoints: Optional[Text] = None,
output: Text = DEFAULT_RESULTS_PATH,
kwargs: Optional[Dict] = None,
):
import rasa.core.test
import rasa.core.utils as core_utils
import rasa.model
from rasa.core.interpreter import RegexInterpreter, NaturalLanguageInterpreter
from rasa.core.agent import Agent
_endpoints = core_utils.AvailableEndpoints.read_endpoints(endpoints)
if kwargs is None:
kwargs = {}
if output:
io_utils.create_directory(output)
try:
unpacked_model = rasa.model.get_model(model)
except ModelNotFound:
print_error(
"Unable to test: could not find a model. Use 'rasa train' to train a "
"Rasa model and provide it via the '--model' argument."
)
return
core_path, nlu_path = rasa.model.get_model_subdirectories(unpacked_model)
if not core_path:
print_error(
"Unable to test: could not find a Core model. Use 'rasa train' to train a "
"Rasa model and provide it via the '--model' argument."
)
use_e2e = kwargs["e2e"] if "e2e" in kwargs else False
_interpreter = RegexInterpreter()
if use_e2e:
if nlu_path:
_interpreter = NaturalLanguageInterpreter.create(_endpoints.nlu or nlu_path)
else:
print_warning(
"No NLU model found. Using default 'RegexInterpreter' for end-to-end "
"evaluation."
)
_agent = Agent.load(unpacked_model, interpreter=_interpreter)
kwargs = utils.minimal_kwargs(kwargs, rasa.core.test, ["stories", "agent"])
loop = asyncio.get_event_loop()
loop.run_until_complete(
rasa.core.test(stories, _agent, out_directory=output, **kwargs)
)
def test_core(
model: Optional[Text] = None,
stories: Optional[Text] = None,
endpoints: Optional[Text] = None,
output: Text = DEFAULT_RESULTS_PATH,
kwargs: Optional[Dict] = None,
):
import rasa.core.test
import rasa.core.utils as core_utils
from rasa.nlu import utils as nlu_utils
from rasa.model import get_model
from rasa.core.interpreter import NaturalLanguageInterpreter
from rasa.core.agent import Agent
_endpoints = core_utils.AvailableEndpoints.read_endpoints(endpoints)
if kwargs is None:
kwargs = {}
if output:
nlu_utils.create_dir(output)
unpacked_model = get_model(model)
if unpacked_model is None:
print_error(
"Unable to test: could not find a model. Use 'rasa train' to train a "
"Rasa model."
)
return
core_path, nlu_path = get_model_subdirectories(unpacked_model)
if not os.path.exists(core_path):
print_error(
"Unable to test: could not find a Core model. Use 'rasa train' to "
"train a model."
)
use_e2e = kwargs["e2e"] if "e2e" in kwargs else False
_interpreter = RegexInterpreter()
if use_e2e:
if os.path.exists(nlu_path):
_interpreter = NaturalLanguageInterpreter.create(nlu_path, _endpoints.nlu)
else:
print_warning(
"No NLU model found. Using default 'RegexInterpreter' for end-to-end "
"evaluation."
)
_agent = Agent.load(unpacked_model, interpreter=_interpreter)
kwargs = minimal_kwargs(kwargs, rasa.core.test, ["stories", "agent"])
loop = asyncio.get_event_loop()
loop.run_until_complete(
rasa.core.test(stories, _agent, out_directory=output, **kwargs)
)
async def test_nlg(http_nlg, trained_rasa_model):
sender = str(uuid.uuid1())
nlg_endpoint = EndpointConfig.from_dict({"url": http_nlg.make_url("/")})
agent = Agent.load(trained_rasa_model, None, generator=nlg_endpoint)
response = await agent.handle_text("/greet", sender_id=sender)
assert len(response) == 1
assert response[0] == {"text": "Hey there!", "recipient_id": sender}
async def conversation_loop(model_path: Text):
agent = Agent.load(model_path)
print("Press 'q' to exit the conversation")
while True:
val = input("input: ")
if val == "q":
break
response = await agent.handle_text(val)
print("Bot: {}".format(response[0]["text"]))
async def parse(text: Text, model_path: Text):
agent = Agent.load(model_path)
response = await agent.handle_text(text)
logger.info(f"Text: '{text}'")
logger.info("Response:")
logger.info(response)
print(response)
return response
