def test_endpoint_config():
endpoint = EndpointConfig(
"https://abc.defg/",
params={"A": "B"},
headers={"X-Powered-By": "Rasa"},
basic_auth={"username": "******",
"password": "******"},
token="mytoken",
token_name="letoken"
)
httpretty.register_uri(
httpretty.POST,
'https://abc.defg/test',
status=500,
body='')
httpretty.enable()
endpoint.request("post", subpath="test",
content_type="application/text",
json={"c": "d"},
params={"P": "1"})
httpretty.disable()
r = httpretty.latest_requests[-1]
assert json.loads(str(r.body.decode("utf-8"))) == {"c": "d"}
assert r.headers.get("X-Powered-By") == "Rasa"
assert r.headers.get("Authorization") == "Basic dXNlcjpwYXNz"
assert r.querystring.get("A") == ["B"]
assert r.querystring.get("P") == ["1"]
assert r.querystring.get("letoken") == ["mytoken"]
def load_rasa_agent():
## path should be changed
interpreter = RasaNLUInterpreter("./rasa/models/nlu/default/chatbot")
action_endpoint = EndpointConfig(url="http://localhost:5055/webhook")
app.rasa_agent = Agent.load("./rasa/models/dialogue",
interpreter=interpreter,action_endpoint=action_endpoint)
# lemma used to preprocess the input
app.lemma = nltk.wordnet.WordNetLemmatizer()
def test_remote_clients(http_app):
client = RasaCoreClient(EndpointConfig(http_app))
cid = str(uuid.uuid1())
client.respond("/greet", cid)
clients = client.clients()
assert cid in clients
def rasa_config():
# Set the actions endpoint
action_endpoint = EndpointConfig(url='http://localhost:5055/webhook')
# Load the trained RASA models
interpreter = RasaNLUInterpreter('./models/current/nlu')
return Agent.load('./models/current/dialogue',
interpreter=interpreter,
action_endpoint=action_endpoint)
def replace_events(endpoint: EndpointConfig, sender_id: Text,
evts: List[Dict[Text, Any]]) -> Dict[Text, Any]:
"""Replace all the events of a conversation with the provided ones."""
subpath = "/conversations/{}/tracker/events".format(sender_id)
r = endpoint.request(json=evts, method="put", subpath=subpath)
return _response_as_json(r)
def test_nlg(http_nlg, default_agent_path):
sender = str(uuid.uuid1())
nlg_endpoint = EndpointConfig.from_dict({"url": http_nlg})
agent = Agent.load(default_agent_path, None, generator=nlg_endpoint)
response = agent.handle_message("/greet", sender_id=sender)
assert len(response) == 1
assert response[0] == {"text": "Hey there!", "recipient_id": sender}
def run_test_bot(serve_forever=True):
interpreter = RasaNLUInterpreter('./models/nlu/default/testbotnlu')
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 send_event(endpoint: EndpointConfig, sender_id: Text,
evt: Dict[Text, Any]) -> Dict[Text, Any]:
"""Log an event to a conversation."""
subpath = "/conversations/{}/tracker/events".format(sender_id)
r = endpoint.request(json=evt, method="post", subpath=subpath)
return _response_as_json(r)
def test_formbot_example():
sys.path.append("examples/formbot/")
p = "examples/formbot/"
stories = os.path.join(p, "data", "stories.md")
endpoint = EndpointConfig("https://abc.defg/webhooks/actions")
endpoints = AvailableEndpoints(action=endpoint)
agent = train_dialogue_model(os.path.join(p, "domain.yml"),
stories,
os.path.join(p, "models", "dialogue"),
endpoints=endpoints,
policy_config="rasa_core/default_config.yml")
response = {
'events': [{
'event': 'form',
'name': 'restaurant_form',
'timestamp': None
}, {
'event': 'slot',
'timestamp': None,
'name': 'requested_slot',
'value': 'cuisine'
}],
'responses': [{
'template': 'utter_ask_cuisine'
}]
}
httpretty.register_uri(httpretty.POST,
'https://abc.defg/webhooks/actions',
body=json.dumps(response))
httpretty.enable()
responses = agent.handle_text("/request_restaurant")
httpretty.disable()
assert responses[0]['text'] == 'what cuisine?'
response = {
"error": "Failed to validate slot cuisine with action restaurant_form",
"action_name": "restaurant_form"
}
httpretty.register_uri(httpretty.POST,
'https://abc.defg/webhooks/actions',
status=400,
body=json.dumps(response))
httpretty.enable()
responses = agent.handle_text("/chitchat")
httpretty.disable()
assert responses[0]['text'] == 'chitchat'
async def test_endpoint_config():
with aioresponses() as mocked:
endpoint = EndpointConfig("https://example.com/",
params={"A": "B"},
headers={"X-Powered-By": "Rasa"},
basic_auth={
"username": "******",
"password": "******"
},
token="mytoken",
token_name="letoken",
type="redis",
port=6379,
db=0,
password="******",
timeout=30000)
mocked.post('https://example.com/test?A=B&P=1&letoken=mytoken',
payload={"ok": True},
repeat=True,
status=200)
await endpoint.request("post",
subpath="test",
content_type="application/text",
json={"c": "d"},
params={"P": "1"})
r = latest_request(mocked, 'post',
"https://example.com/test?A=B&P=1&letoken=mytoken")
assert r
assert json_of_latest_request(r) == {"c": "d"}
assert r[-1].kwargs.get("params", {}).get("A") == "B"
assert r[-1].kwargs.get("params", {}).get("P") == "1"
assert r[-1].kwargs.get("params", {}).get("letoken") == "mytoken"
# unfortunately, the mock library won't report any headers stored on
# the session object, so we need to verify them separately
async with endpoint.session() as s:
assert s._default_headers.get("X-Powered-By") == "Rasa"
assert s._default_auth.login == "user"
assert s._default_auth.password == "pass"
def load_agent():
action_endpoint = EndpointConfig(url="http://localhost:8000/webhook")
interpreter = RasaNLUInterpreter("./models/default/nlu")
agent = Agent.load(
"./models/dialogue",
interpreter=interpreter,
action_endpoint=action_endpoint,
)
return agent
def __init__(self, model_name=None, endpoint=None, project_name='default'):
# type: (Text, EndpointConfig, Text) -> None
self.model_name = model_name
self.project_name = project_name
if endpoint:
self.endpoint = endpoint
else:
self.endpoint = EndpointConfig(constants.DEFAULT_SERVER_URL)
def run_happsales_bot(serve_forever=True):
interpreter = RasaNLUInterpreter(
'/home/saradindu/dev/Work-II/Happsales/models/nlu/default/happsales')
action_endpoint = EndpointConfig(url="http://localhost:5055/webhook")
agent = Agent.load('/home/saradindu/dev/Work-II/Happsales/models/dialogue',
interpreter=interpreter,
action_endpoint=action_endpoint)
rasa_core.run.serve_application(agent, channel='cmdline')
return agent
def test_sorted_predict(http_app, app):
client = RasaCoreClient(EndpointConfig(http_app))
cid = str(uuid.uuid1())
for event in test_events[:3]:
client.append_event_to_tracker(cid, event)
response = app.post("http://dummy/conversations/{}/predict".format(cid))
content = response.get_json()
scores = content["scores"]
sorted_scores = sorted(scores, key=lambda k: (-k['score'], k['action']))
assert scores == sorted_scores
def run_malu_bot(serve_forever=True):
interpreter = RasaNLUInterpreter(
'./models/nlu/default/malu') #carrega o modelo de nlu
action_endpoint = EndpointConfig(url="http://localhost:5055/webhook")
agent = Agent.load('./models/dialogue',
interpreter=interpreter,
action_endpoint=action_endpoint) #carregar um agente
serve_application(agent, channel='cmdline')
return agent
def request_prediction(
endpoint: EndpointConfig,
sender_id: Text
) -> Dict[Text, Any]:
"""Request the next action prediction from core."""
r = endpoint.request(method="post",
subpath="/conversations/{}/predict".format(sender_id))
return _response_as_json(r)
def test_tracker_store_endpoint_config_loading():
cfg = utils.read_endpoint_config(DEFAULT_ENDPOINTS_FILE, "tracker_store")
assert cfg == EndpointConfig.from_dict({
"type": "redis",
"url": "localhost",
"port": 6379,
"db": 0,
"password": "******",
"timeout": 30000
})
def run_core(core_model_path, nlu_model_path, action_endpoint_url,
slack_token):
nlu_interpreter = RasaNLUInterpreter(nlu_model_path)
action_endpoint = EndpointConfig(url=action_endpoint_url)
agent = Agent.load(core_model_path,
interpreter=nlu_interpreter,
action_endpoint=action_endpoint)
input_channel = SlackInput(slack_token)
agent.handle_channels([input_channel], 5002, serve_forever=True)
return agent
def send_finetune(
endpoint: EndpointConfig,
evts: List[Dict[Text, Any]]
) -> Dict[Text, Any]:
"""Finetune a core model on the provided additional training samples."""
r = endpoint.request(json=evts,
method="post",
subpath="/finetune")
return _response_as_json(r)
def test_remote_action_endpoint_not_running(default_dispatcher_collecting,
default_domain):
tracker = DialogueStateTracker("default", default_domain.slots)
endpoint = EndpointConfig("https://abc.defg/webhooks/actions")
remote_action = action.RemoteAction("my_action", endpoint)
with pytest.raises(Exception) as execinfo:
remote_action.run(default_dispatcher_collecting, tracker,
default_domain)
assert "Failed to execute custom action." in str(execinfo.value)
def test_predict(http_app, app):
client = RasaCoreClient(EndpointConfig(http_app))
cid = str(uuid.uuid1())
for event in test_events[:2]:
client.append_event_to_tracker(cid, event)
out = app.get('/domain', headers={'Accept': 'yml'})
domain = TemplateDomain.from_yaml(out.get_data())
tracker = client.tracker(cid, domain)
event_dicts = [ev.as_dict() for ev in tracker.applied_events()]
response = app.post('/predict', json=event_dicts)
assert response.status_code == 200
def run_weather_online(interpreter, domain_file="weather_domain.yml", training_data_file = './data/stories.md'): action_endpoint = EndpointConfig(url = "http://localhost:5005/webhook") agent = Agent(domain_file, policies = [MemoizationPolicy(max_history = 2), KerasPolicy(max_history = 3, epochs = 3, batch_size = 50)], interpreter = interpreter, action_endpoint = action_endpoint) training_data = agent.load_data(training_data_file) agent.train(training_data) interactive.run_interactive_learning(agent, training_data_file) return agent
def run_restaurant_bot(serve_forever=True):
interpreter = RasaNLUInterpreter('./models/nlu/default/restaurantnlu')
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')
#if serve_forever:
# agent.handle_channel(ConsoleInputChannel())
return agent
async def test_formbot_example():
sys.path.append("examples/formbot/")
p = "examples/formbot/"
stories = os.path.join(p, "data", "stories.md")
endpoint = EndpointConfig("https://example.com/webhooks/actions")
endpoints = AvailableEndpoints(action=endpoint)
agent = await train(os.path.join(p, "domain.yml"),
stories,
os.path.join(p, "models", "dialogue"),
endpoints=endpoints,
policy_config="rasa_core/default_config.yml")
response = {
'events': [{
'event': 'form',
'name': 'restaurant_form',
'timestamp': None
}, {
'event': 'slot',
'timestamp': None,
'name': 'requested_slot',
'value': 'cuisine'
}],
'responses': [{
'template': 'utter_ask_cuisine'
}]
}
with aioresponses() as mocked:
mocked.post('https://example.com/webhooks/actions',
payload=response,
repeat=True)
responses = await agent.handle_text("/request_restaurant")
assert responses[0]['text'] == 'what cuisine?'
response = {
"error": "Failed to validate slot cuisine with action "
"restaurant_form",
"action_name": "restaurant_form"
}
with aioresponses() as mocked:
# noinspection PyTypeChecker
mocked.post('https://example.com/webhooks/actions',
repeat=True,
exception=ClientResponseError(400, "",
json.dumps(response)))
responses = await agent.handle_text("/chitchat")
assert responses[0]['text'] == 'chitchat'
def run(serve_forever=True):
interpreter = RasaNLUInterpreter("models/nlu/default/current")
action_endpoint = EndpointConfig(url="http://0.0.0.0:5055/webhook")
agent = Agent.load("models/dialogue",
interpreter=interpreter,
action_endpoint=action_endpoint)
print("Your bot is ready to talk! Type your messages here or send 'stop'")
while True:
responses = agent.handle_text(input())
for response in responses:
print(response["text"])
return agent
def test_nlg(http_nlg, default_agent_path):
sender = str(uuid.uuid1())
nlg_endpoint = EndpointConfig.from_dict({
"url": http_nlg
})
agent = Agent.load(default_agent_path, None,
generator=nlg_endpoint)
response = agent.handle_message("/greet", sender_id=sender)
assert len(response) == 1
assert response[0] == {"text": "Hey there!", "recipient_id": sender}
def agnt(st):
nlu_interpreter = RasaNLUInterpreter('/app/models/rasa_nlu/current/nlu')
core='/app/models/rasa_core'
action_endpoint = EndpointConfig(url="http://localhost:5055/webhook")
agent = Agent.load(path=core, interpreter = nlu_interpreter, action_endpoint = action_endpoint)
input_channel = SlackInput(st)
agent.handle_channels([input_channel], 5005, serve_forever=True)
def test_remote_append_events(http_app):
client = RasaCoreClient(EndpointConfig(http_app))
cid = str(uuid.uuid1())
client.append_events_to_tracker(cid, test_events[:2])
tracker = client.tracker_json(cid)
evts = tracker.get("events")
expected = [ActionExecuted(ACTION_LISTEN_NAME)] + test_events[:2]
assert events.deserialise_events(evts) == expected
def run_recruitment_bot():
'''
Initialize bot for chat.
:return: agent
'''
interpreter = RasaNLUInterpreter('./models/nlu/default/current')
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 train_interactive():
current_directory = os.path.dirname(os.path.realpath(__file__))
domain_file = 'domain.yml'
interpreter = RasaNLUInterpreter(current_directory + '/agent-data/models/nlu/default/current')
action_endpoint = EndpointConfig(url=actionIP)
stories_file = current_directory + '/agent-data/data/stories.md'
agent = Agent(domain_file,
policies=[MemoizationPolicy(max_history=5), KerasPolicy()],
interpreter=interpreter, action_endpoint=action_endpoint)
data = agent.load_data(stories_file)
agent.train(data)
interactive.run_interactive_learning(agent, stories_file)
return agent
def load_agent():
p = "examples/formbot/"
strpath = os.path.join(p, "models", "dialogue")
endpoint = EndpointConfig("http://localhost:5055/webhook")
endpoints = AvailableEndpoints(action=endpoint)
loaded = Agent.load(strpath,
interpreter=RegexInterpreter(),
action_endpoint=endpoints.action)
# loaded = Agent.load(strpath, interpreter=RegexInterpreter())
responses = loaded.handle_text("/request_restaurant")
print(responses[0])
responses = loaded.handle_text("/chitchat")
print(responses)
def retrieve_tracker(
endpoint: EndpointConfig,
sender_id: Text,
verbosity: EventVerbosity = EventVerbosity.ALL) -> Dict[Text, Any]:
"""Retrieve a tracker from core."""
path = "/conversations/{}/tracker?include_events={}".format(
sender_id, verbosity.name)
r = endpoint.request(method="get",
subpath=path,
headers={"Accept": "application/json"})
return _response_as_json(r)
def test_agent_with_model_server(tmpdir, zipped_moodbot_model):
fingerprint = 'somehash'
model_endpoint_config = EndpointConfig.from_dict(
{"url": 'http://server.com/model/default_core@latest'}
)
# mock a response that returns a zipped model
with io.open(zipped_moodbot_model, 'rb') as f:
responses.add(responses.GET,
model_endpoint_config.url,
headers={"ETag": fingerprint},
body=f.read(),
content_type='application/zip',
stream=True)
agent = rasa_core.agent.load_from_server(model_server=model_endpoint_config)
assert agent.fingerprint == fingerprint
def test_nlg_endpoint_config_loading():
cfg = utils.read_endpoint_config(DEFAULT_ENDPOINTS_FILE, "nlg")
assert cfg == EndpointConfig.from_dict({
"url": "http://localhost:5055/nlg"
})
