def create_agent(model: Text, endpoints: Text = None) -> 'Agent':
from rasa.core.interpreter import RasaNLUInterpreter
from rasa.core.tracker_store import TrackerStore
from rasa.core import broker
from rasa.core.utils import AvailableEndpoints
core_path, nlu_path = get_model_subdirectories(model)
_endpoints = AvailableEndpoints.read_endpoints(endpoints)
_interpreter = None
if os.path.exists(nlu_path):
_interpreter = RasaNLUInterpreter(model_directory=nlu_path)
else:
_interpreter = None
logging.info("No NLU model found. Running without NLU.")
_broker = broker.from_endpoint_config(_endpoints.event_broker)
_tracker_store = TrackerStore.find_tracker_store(None,
_endpoints.tracker_store,
_broker)
return Agent.load(core_path,
generator=_endpoints.nlg,
tracker_store=_tracker_store,
action_endpoint=_endpoints.action)
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 load_agent_on_start(
model_path: Text,
endpoints: AvailableEndpoints,
remote_storage: Optional[Text],
app: Sanic,
loop: Text,
):
"""Load an agent.
Used to be scheduled on server start
(hence the `app` and `loop` arguments)."""
from rasa.core import broker
try:
unpacked_model_context = get_model(model_path)
if unpacked_model_context:
with unpacked_model_context as unpacked_model:
_, nlu_model = get_model_subdirectories(unpacked_model)
_interpreter = NaturalLanguageInterpreter.create(
nlu_model, endpoints.nlu
)
else:
raise RuntimeError("No model found at '{}'.".format(model_path))
except Exception:
logger.debug("Could not load interpreter from '{}'.".format(model_path))
_interpreter = None
_broker = broker.from_endpoint_config(endpoints.event_broker)
_tracker_store = TrackerStore.find_tracker_store(
None, endpoints.tracker_store, _broker
)
model_server = endpoints.model if endpoints and endpoints.model else None
app.agent = await load_agent(
model_path,
model_server=model_server,
remote_storage=remote_storage,
interpreter=_interpreter,
generator=endpoints.nlg,
tracker_store=_tracker_store,
action_endpoint=endpoints.action,
)
if not app.agent:
logger.warning(
"Agent could not be loaded with the provided configuration. "
"Load default agent without any model."
)
app.agent = Agent(
interpreter=_interpreter,
generator=endpoints.nlg,
tracker_store=_tracker_store,
action_endpoint=endpoints.action,
model_server=model_server,
remote_storage=remote_storage,
)
return app.agent
def test_file_broker_from_config():
cfg = read_endpoint_config(
"data/test_endpoints/event_brokers/file_endpoint.yml", "event_broker")
actual = broker.from_endpoint_config(cfg)
assert isinstance(actual, FileProducer)
assert actual.path == "rasa_event.log"
def test_sql_broker_from_config():
cfg = read_endpoint_config(
"data/test_endpoints/event_brokers/sql_endpoint.yml", "event_broker"
)
actual = broker.from_endpoint_config(cfg)
assert isinstance(actual, SQLProducer)
assert actual.engine.name == "sqlite"
def test_pika_broker_from_config():
cfg = read_endpoint_config(
"data/test_endpoints/event_brokers/pika_endpoint.yml", "event_broker")
actual = broker.from_endpoint_config(cfg)
assert isinstance(actual, PikaProducer)
assert actual.host == "localhost"
assert actual.credentials.username == "username"
assert actual.queue == "queue"
def test_sql_broker_logs_to_sql_db():
cfg = read_endpoint_config(
"data/test_endpoints/event_brokers/sql_endpoint.yml", "event_broker"
)
actual = broker.from_endpoint_config(cfg)
for e in TEST_EVENTS:
actual.publish(e.as_dict())
events_types = [
json.loads(event.data)["event"]
for event in actual.session.query(actual.SQLBrokerEvent).all()
]
assert events_types == ["user", "slot", "restart"]
def test_file_broker_logs_to_file(tmpdir):
fname = tmpdir.join("events.log").strpath
actual = broker.from_endpoint_config(
EndpointConfig(**{"type": "file", "path": fname})
)
for e in TEST_EVENTS:
actual.publish(e.as_dict())
# reading the events from the file one event per line
recovered = []
with open(fname, "r") as f:
for l in f:
recovered.append(Event.from_parameters(json.loads(l)))
assert recovered == TEST_EVENTS
def test_file_broker_properly_logs_newlines(tmpdir):
fname = tmpdir.join("events.log").strpath
actual = broker.from_endpoint_config(
EndpointConfig(**{"type": "file", "path": fname})
)
event_with_newline = UserUttered("hello \n there")
actual.publish(event_with_newline.as_dict())
# reading the events from the file one event per line
recovered = []
with open(fname, "r") as f:
for l in f:
recovered.append(Event.from_parameters(json.loads(l)))
assert recovered == [event_with_newline]
async def _load_agent(
model_path: Optional[Text] = None,
model_server: Optional[EndpointConfig] = None,
remote_storage: Optional[Text] = None,
endpoints: Optional[AvailableEndpoints] = None,
) -> Agent:
try:
tracker_store = None
generator = None
action_endpoint = None
if endpoints:
_broker = broker.from_endpoint_config(endpoints.event_broker)
tracker_store = TrackerStore.find_tracker_store(
None, endpoints.tracker_store, _broker)
generator = endpoints.nlg
action_endpoint = endpoints.action
loaded_agent = await load_agent(
model_path,
model_server,
remote_storage,
generator=generator,
tracker_store=tracker_store,
action_endpoint=action_endpoint,
)
except Exception as e:
logger.debug(traceback.format_exc())
raise ErrorResponse(
500, "LoadingError",
"An unexpected error occurred. Error: {}".format(e))
if not loaded_agent:
raise ErrorResponse(
400,
"BadRequest",
"Agent with name '{}' could not be loaded.".format(model_path),
{
"parameter": "model",
"in": "query"
},
)
return loaded_agent
def create_agent(model: Text, endpoints: Text = None) -> "Agent":
from rasa.core.tracker_store import TrackerStore
from rasa.core import broker
from rasa.core.utils import AvailableEndpoints
_endpoints = AvailableEndpoints.read_endpoints(endpoints)
_broker = broker.from_endpoint_config(_endpoints.event_broker)
_tracker_store = TrackerStore.find_tracker_store(None,
_endpoints.tracker_store,
_broker)
return Agent.load(
model,
generator=_endpoints.nlg,
tracker_store=_tracker_store,
action_endpoint=_endpoints.action,
)
def test_load_non_existent_custom_broker_name():
config = EndpointConfig(**{"type": "rasa.core.broker.MyProducer"})
assert broker.from_endpoint_config(config) is None
def test_load_custom_broker_name():
config = EndpointConfig(**{"type": "rasa.core.broker.FileProducer"})
assert broker.from_endpoint_config(config)
def test_no_broker_in_config():
cfg = read_endpoint_config(DEFAULT_ENDPOINTS_FILE, "event_broker")
actual = broker.from_endpoint_config(cfg)
assert actual is None
