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
_endpoints = AvailableEndpoints.read_endpoints(endpoints)
if not connector and not credentials:
connector = "rest"
print_warning(
f"No chat connector configured, falling back to the "
f"REST input channel. To connect your bot to another channel, "
f"read the docs here: {DOCS_BASE_URL}/messaging-and-voice-channels"
)
kwargs = rasa.shared.utils.common.minimal_kwargs(
kwargs, rasa.core.run.serve_application)
rasa.core.run.serve_application(
model,
channel=connector,
credentials=credentials,
endpoints=_endpoints,
**kwargs,
)
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
_endpoints = AvailableEndpoints.read_endpoints(endpoints)
_broker = 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 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
from rasa.core.agent import Agent
_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 _get_old_tracker_store(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 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
from rasa.core.utils import AvailableEndpoints
model_path = get_model(model)
core_path, nlu_path = get_model_subdirectories(model_path)
_endpoints = AvailableEndpoints.read_endpoints(endpoints)
if not connector and not credentials:
channel = "cmdline"
logger.info("No chat connector configured, falling back to the "
"command line. Use `rasa configure channel` to connect"
"the bot to e.g. facebook messenger.")
else:
channel = connector
kwargs = minimal_kwargs(kwargs, rasa.core.run.serve_application)
rasa.core.run.serve_application(core_path,
nlu_path,
channel=channel,
credentials_file=credentials,
endpoints=_endpoints,
**kwargs)
shutil.rmtree(model_path)
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(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))
# 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,
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))