def _get_tracker_store_from_endpoints_config(
endpoints_file: Text) -> TrackerStore:
if (not endpoints_file or not os.path.isfile(endpoints_file)
or not os.path.exists(endpoints_file)):
print_error(
"File '{}' was not found. Please specify a valid file with "
"'--endpoints <file>'.".format(endpoints_file))
exit(1)
endpoints = AvailableEndpoints.read_endpoints(endpoints_file)
tracker_store = TrackerStore.find_tracker_store(Domain.empty(),
endpoints.tracker_store)
if not tracker_store or isinstance(tracker_store, InMemoryTrackerStore):
print_error(
"No valid tracker store config given. Please provide a valid "
"tracker store configuration as it is described here: "
"https://rasa.com/docs/core/0.14.4/tracker_stores/")
exit(1)
return tracker_store
def create_agent(model: Text, endpoints: Text = None) -> "Agent":
from rasa.core.tracker_store import TrackerStore
import rasa.core.brokers.utils as broker_utils
from rasa.core.utils import AvailableEndpoints
from rasa.core.agent import Agent
_endpoints = AvailableEndpoints.read_endpoints(endpoints)
_broker = broker_utils.from_endpoint_config(_endpoints.event_broker)
_tracker_store = TrackerStore.find_tracker_store(None,
_endpoints.tracker_store,
_broker)
_lock_store = LockStore.find_lock_store(_endpoints.lock_store)
return Agent.load(
model,
generator=_endpoints.nlg,
tracker_store=_tracker_store,
lock_store=_lock_store,
action_endpoint=_endpoints.action,
)
def create_agent(model: Text, endpoints: Text = None) -> "Agent":
from rasa.core.tracker_store import TrackerStore
from rasa.core.utils import AvailableEndpoints
from rasa.core.agent import Agent
from rasa.core.brokers.broker import EventBroker
import rasa.utils.common
_endpoints = AvailableEndpoints.read_endpoints(endpoints)
_broker = rasa.utils.common.run_in_loop(
EventBroker.create(_endpoints.event_broker))
_tracker_store = TrackerStore.create(_endpoints.tracker_store,
event_broker=_broker)
_lock_store = LockStore.create(_endpoints.lock_store)
return Agent.load(
model,
generator=_endpoints.nlg,
tracker_store=_tracker_store,
lock_store=_lock_store,
action_endpoint=_endpoints.action,
)
def run_interactive_learning(stories: Text = None,
finetune: bool = False,
skip_visualization: bool = False,
server_args: Dict[Text, Any] = None,
additional_arguments: Dict[Text, Any] = None
):
"""Start the interactive learning with the model of the agent."""
server_args = server_args or {}
if not skip_visualization:
p = Process(target=start_visualization, args=("story_graph.dot",))
p.deamon = True
p.start()
else:
p = None
app = run.configure_app(enable_api=True)
endpoints = AvailableEndpoints.read_endpoints(server_args.get("endpoints"))
# before_server_start handlers make sure the agent is loaded before the
# interactive learning IO starts
if server_args.get("core"):
app.register_listener(
partial(run.load_agent_on_start, server_args.get("core"),
endpoints, server_args.get("nlu")),
'before_server_start')
else:
app.register_listener(
partial(train_agent_on_start, server_args, endpoints,
additional_arguments),
'before_server_start')
_serve_application(app, stories, finetune, skip_visualization)
if not skip_visualization:
p.terminate()
p.join()
def run(model: Text,
endpoints: Text,
connector: Text = None,
credentials: Text = None,
**kwargs: Dict):
"""Runs a Rasa model.
Args:
model: Path to model archive.
endpoints: Path to endpoints file.
connector: Connector which should be use (overwrites `credentials`
field).
credentials: Path to channel credentials file.
**kwargs: Additional arguments which are passed to
`rasa.core.run.serve_application`.
"""
import rasa.core.run
import rasa.nlu.run
from rasa.core.utils import AvailableEndpoints
import rasa.utils.common as utils
_endpoints = AvailableEndpoints.read_endpoints(endpoints)
if not connector and not credentials:
connector = "rest"
print_warning(
"No chat connector configured, falling back to the "
"REST input channel. To connect your bot to another channel, "
"read the docs here: {}/user-guide/"
"messaging-and-voice-channels".format(DOCS_BASE_URL))
kwargs = utils.minimal_kwargs(kwargs, rasa.core.run.serve_application)
rasa.core.run.serve_application(model,
channel=connector,
credentials=credentials,
endpoints=_endpoints,
**kwargs)
async def test_load_agent_on_start_with_bad_model_file(
tmp_path: Path,
rasa_server: Sanic,
loop: AbstractEventLoop,
):
fake_model = tmp_path / "fake_model.tar.gz"
fake_model.touch()
fake_model_path = str(fake_model)
with pytest.warns(UserWarning) as warnings:
agent = await run.load_agent_on_start(
fake_model_path,
AvailableEndpoints(),
None,
rasa_server,
loop,
)
assert any("fake_model.tar.gz' could not be loaded" in str(w.message)
for w in warnings)
# Fallback agent was loaded even if model was unusable
assert isinstance(agent.interpreter, interpreter.RegexInterpreter)
assert agent.policy_ensemble is None
assert isinstance(agent.domain, domain.Domain)
def track_server_start(
input_channels: List["InputChannel"],
endpoints: Optional["AvailableEndpoints"],
model_directory: Optional[Text],
number_of_workers: int,
is_api_enabled: bool,
) -> None:
"""Tracks when a user starts a rasa server.
Args:
input_channels: Used input channels
endpoints: Endpoint configuration for the server
model_directory: directory of the running model
number_of_workers: number of used Sanic workers
is_api_enabled: whether the rasa API server is enabled
"""
from rasa.core.utils import AvailableEndpoints
def project_fingerprint_from_model(
_model_directory: Optional[Text], ) -> Optional[Text]:
"""Gets project fingerprint from an app's loaded model."""
if not model_directory:
return None
try:
model_archive = model.get_local_model(_model_directory)
metadata = LocalModelStorage.metadata_from_archive(model_archive)
return metadata.project_fingerprint
except Exception:
return None
if not endpoints:
endpoints = AvailableEndpoints()
_track(
TELEMETRY_SERVER_STARTED_EVENT,
{
"input_channels": [i.name() for i in input_channels],
"api_enabled":
is_api_enabled,
"number_of_workers":
number_of_workers,
"endpoints_nlg":
endpoints.nlg.type if endpoints.nlg else None,
"endpoints_nlu":
endpoints.nlu.type if endpoints.nlu else None,
"endpoints_action_server":
endpoints.action.type if endpoints.action else None,
"endpoints_model_server":
endpoints.model.type if endpoints.model else None,
"endpoints_tracker_store":
endpoints.tracker_store.type if endpoints.tracker_store else None,
"endpoints_lock_store":
endpoints.lock_store.type if endpoints.lock_store else None,
"endpoints_event_broker":
endpoints.event_broker.type if endpoints.event_broker else None,
"project":
project_fingerprint_from_model(model_directory),
},
)
def test_default_wait_time_between_pulls():
endpoint_config = EndpointConfig(url="http://*****:*****@latest")
endpoints = AvailableEndpoints(model=endpoint_config)
x._overwrite_endpoints_for_local_x(endpoints, "test", "http://localhost")
assert endpoints.model.kwargs["wait_time_between_pulls"] == 2
def _overwrite_endpoints_for_local_x(endpoints: AvailableEndpoints,
rasa_x_token: Text, rasa_x_url: Text):
endpoints.model = _get_model_endpoint(endpoints.model, rasa_x_token,
rasa_x_url)
endpoints.event_broker = _get_event_broker_endpoint(endpoints.event_broker)
def test_default_model_server_url():
endpoint_config = EndpointConfig()
endpoints = AvailableEndpoints(model=endpoint_config)
x._overwrite_endpoints_for_local_x(endpoints, "test", "http://localhost")
assert (endpoints.model.url ==
"http://localhost/projects/default/models/tag/production")
def test_overwrite_model_server_url_with_no_model_endpoint():
endpoints = AvailableEndpoints()
x._overwrite_endpoints_for_local_x(endpoints, "test", "http://localhost")
assert (endpoints.model.url ==
"http://localhost/projects/default/models/tag/production")
def run(args: argparse.Namespace) -> NoReturn:
"""Entrypoint for `rasa run`.
Args:
args: The CLI arguments.
"""
import rasa
args.endpoints = rasa.cli.utils.get_validated_path(args.endpoints,
"endpoints",
DEFAULT_ENDPOINTS_PATH,
True)
args.credentials = rasa.cli.utils.get_validated_path(
args.credentials, "credentials", DEFAULT_CREDENTIALS_PATH, True)
if args.enable_api:
if not args.remote_storage:
args.model = _validate_model_path(args.model, "model",
DEFAULT_MODELS_PATH)
rasa.run(**vars(args))
return
# if the API is not enable you cannot start without a model
# make sure either a model server, a remote storage, or a local model is
# configured
from rasa.model import get_model
from rasa.core.utils import AvailableEndpoints
# start server if remote storage is configured
if args.remote_storage is not None:
rasa.run(**vars(args))
return
# start server if model server is configured
endpoints = AvailableEndpoints.read_endpoints(args.endpoints)
model_server = endpoints.model if endpoints and endpoints.model else None
if model_server is not None:
rasa.run(**vars(args))
return
# start server if local model found
args.model = _validate_model_path(args.model, "model", DEFAULT_MODELS_PATH)
local_model_set = True
try:
get_model(args.model)
except ModelNotFound:
local_model_set = False
if local_model_set:
rasa.run(**vars(args))
return
rasa.shared.utils.cli.print_error(
f"No model found. You have three options to provide a model:\n"
f"1. Configure a model server in the endpoint configuration and provide "
f"the configuration via '--endpoints'.\n"
f"2. Specify a remote storage via '--remote-storage' to load the model "
f"from.\n"
f"3. Train a model before running the server using `rasa train` and "
f"use '--model' to provide the model path.\n"
f"For more information check {DOCS_BASE_URL}/model-storage.")
from sqlalchemy.ext.declarative import declarative_base
import sqlalchemy.exc
from sqlalchemy.orm import relationship
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
import psycopg2
from rasa.core.utils import AvailableEndpoints
import requests
import json
import logging
import random
import time
import datetime
logger = logging.getLogger(__name__)
_endpoints = AvailableEndpoints.read_endpoints("endpoints.yml")
_credentials = rasa.utils.io.read_config_file("credentials.yml")
# To get FB User Profile, use something like:
# See: https://developers.facebook.com/tools/explorer
# and https://developers.facebook.com/docs/graph-api/explorer/
Base = declarative_base()
class Human(Base):
__tablename__ = 'human'
id = Column(Integer, primary_key=True)
fb_id = Column(String(250))
first_name = Column(String(250))
last_name = Column(String(250))
nlu_model, app, loop)
tracker = load_tracker_from_json(tracker_dump,
agent.domain)
await replay_events(tracker, agent)
app.register_listener(load_agent_and_tracker, 'before_server_start')
app.run(host='0.0.0.0', port=port,
access_log=logger.isEnabledFor(logging.DEBUG))
if __name__ == '__main__':
# Running as standalone python application
arg_parser = create_argument_parser()
cmdline_args = arg_parser.parse_args()
rasa.utils.configure_colored_logging(cmdline_args.loglevel)
_endpoints = AvailableEndpoints.read_endpoints(cmdline_args.endpoints)
print(cliutils.wrap_with_color(
"We'll recreate the dialogue state. After that you can chat "
"with the bot, continuing the input conversation.",
rasa.cli.utils.bcolors.OKGREEN + rasa.cli.utils.bcolors.UNDERLINE))
_loop = asyncio.get_event_loop()
_loop.run_until_complete(serve_application(cmdline_args.core,
cmdline_args.nlu,
cmdline_args.port,
cmdline_args.enable_api,
_endpoints))
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="examples/formbot/config.yml",
)
async def mock_form_happy_path(input_text, output_text, slot=None):
if slot:
form = "restaurant_form"
template = f"utter_ask_{slot}"
else:
form = None
template = "utter_submit"
response = {
"events": [
{
"event": "form",
"name": form,
"timestamp": None
},
{
"event": "slot",
"timestamp": None,
"name": "requested_slot",
"value": slot,
},
],
"responses": [{
"template": template
}],
}
with aioresponses() as mocked:
mocked.post("https://example.com/webhooks/actions",
payload=response,
repeat=True)
responses = await agent.handle_text(input_text)
assert responses[0]["text"] == output_text
async def mock_form_unhappy_path(input_text, output_text, slot):
response_error = {
"error":
f"Failed to extract slot {slot} 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_error)),
)
responses = await agent.handle_text(input_text)
assert responses[0]["text"] == output_text
await mock_form_happy_path("/request_restaurant",
"what cuisine?",
slot="cuisine")
await mock_form_unhappy_path("/chitchat", "chitchat", slot="cuisine")
await mock_form_happy_path('/inform{"cuisine": "mexican"}',
"how many people?",
slot="num_people")
await mock_form_happy_path('/inform{"number": "2"}',
"do you want to seat outside?",
slot="outdoor_seating")
await mock_form_happy_path("/affirm",
"please provide additional preferences",
slot="preferences")
responses = await agent.handle_text("/restart")
assert responses[0]["text"] == "restarted"
responses = await agent.handle_text("/greet")
assert (responses[0]["text"] ==
"Hello! I am restaurant search assistant! How can I help?")
await mock_form_happy_path("/request_restaurant",
"what cuisine?",
slot="cuisine")
await mock_form_happy_path('/inform{"cuisine": "mexican"}',
"how many people?",
slot="num_people")
await mock_form_happy_path('/inform{"number": "2"}',
"do you want to seat outside?",
slot="outdoor_seating")
await mock_form_unhappy_path("/stop",
"do you want to continue?",
slot="outdoor_seating")
await mock_form_happy_path("/affirm",
"do you want to seat outside?",
slot="outdoor_seating")
await mock_form_happy_path("/affirm",
"please provide additional preferences",
slot="preferences")
await mock_form_happy_path(
"/deny",
"please give your feedback on your experience so far",
slot="feedback")
await mock_form_happy_path('/inform{"feedback": "great"}', "All done!")
responses = await agent.handle_text("/thankyou")
assert responses[0]["text"] == "you are welcome :)"
# app.blueprint(html_bp)
# app.blueprint(json_bp)
# TODO 从配置文件获取配置
CONFIG = load_config()
BASE_CORE_PATH = "core/"
enable_api = True
cors = None
auth_token = None
jwt_secret = None
jwt_method = None
# aws,gcs,azure
remote_storage = None
endpoints = get_validated_path(BASE_CORE_PATH + "endpoints.yml", "endpoints",
DEFAULT_ENDPOINTS_PATH, True)
_endpoints = AvailableEndpoints.read_endpoints(endpoints)
port = DEFAULT_RASA_PORT
# model = get_validated_path(BASE_CORE_PATH+"models/", "model", DEFAULT_MODELS_PATH)
# model_path = BASE_CORE_PATH+"models/"
model_path = CONFIG.BASE_MODEL_DIR
if __name__ == "__main__":
if not model_path:
print("No model found. Train a model before running the server")
app = server.create_app(cors_origins=cors,
auth_token=auth_token,
jwt_secret=jwt_secret,
jwt_method=jwt_method,
endpoints=endpoints,
def test_overwrite_model_server_url():
endpoint_config = EndpointConfig(
url="http://*****:*****@latest")
endpoints = AvailableEndpoints(model=endpoint_config)
x._overwrite_endpoints_for_local_x(endpoints, "test", "http://localhost")
assert endpoints.model.url == "http://localhost/models/tags/production"
