Example #1
0
def main(args):
    pre_load = args.pre_load

    _endpoints = read_endpoints(args.endpoints)

    router = DataRouter(
        args.path,
        args.max_training_processes,
        args.response_log,
        args.emulate,
        args.storage,
        model_server=_endpoints.model,
        wait_time_between_pulls=args.wait_time_between_pulls,
    )

    if pre_load:
        logger.debug("Preloading....")
        if "all" in pre_load:
            pre_load = router.project_store.keys()
        router._pre_load(pre_load)

    rasa = create_app(
        router, args.loglevel, args.write, get_token(args.token), args.cors
    )
    rasa.add_task(configure_logging)

    logger.info("Started http server on port %s" % args.port)

    rasa.run(
        host="0.0.0.0",
        port=args.port,
        workers=1,
        access_log=logger.isEnabledFor(logging.DEBUG),
    )
Example #2
0
def main(args):
    _endpoints = read_endpoints(args.endpoints)

    loop = asyncio.get_event_loop()
    if loop.is_closed():
        loop = asyncio.new_event_loop()

    router = loop.run_until_complete(
        create_data_router(
            args.model,
            args.max_training_processes,
            args.response_log,
            args.emulate,
            args.storage,
            model_server=_endpoints.model,
            wait_time_between_pulls=args.wait_time_between_pulls,
        ))

    loop.close()

    rasa = create_app(router, args.loglevel, args.write, get_token(args.token),
                      args.cors)
    rasa.add_task(configure_logging)

    logger.info("Started http server on port %s" % args.port)

    rasa.run(
        host="0.0.0.0",
        port=args.port,
        workers=1,
        access_log=logger.isEnabledFor(logging.DEBUG),
    )
Example #3
0
# -*- coding: utf-8 -*-
'''
@Author  :   Xu

@Software:   PyCharm

@File    :   bot.py

@Time    :   2019-09-25 14:23

@Desc    :   可用于代码断点调试

'''

from rasa.core.channels.socketio import SocketIOInput
from rasa.core.agent import Agent
import rasa
import pathlib
import os

basedir = str(pathlib.Path(os.path.abspath(__file__)).parent)
model = basedir + "/models"

# model = "/home/xsq/nlp_code/Chatbot_RASA/models"
endpoints = "config/endpoints.yml"
credentials = "config/credentials.yml"
#
ss = rasa.run(model=model, endpoints=endpoints, credentials=credentials)
Example #4
0
import logging
import rasa

logging.info("attempting to run rasa")

# Make necessary bindings
# Todo: Add to .env
model_path = "./rasa_folder/models/latest.tar.gz"
model_name = "latest"
domain_path = "./rasa_folder/domain.yml"
credentials_path = "./rasa_folder/credentials.yml"
endpoints_path = "./rasa_folder/endpoints.yml"
config_path = "./rasa_folder/config.yml"
training_data_path = "./rasa_folder/data"
output_path = "./rasa_folder/models"

# Train if needed
rasa.train(domain=domain_path,
           config=config_path,
           training_files=training_data_path,
           output=output_path,
           fixed_model_name=model_name)

# Run Rasa
rasa.run(model=model_path,
         endpoints=endpoints_path,
         port=5005,
         cors="*",
         connector="rest",
         enable_api=True)
Example #5
0
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.")
Example #6
0
import os
import rasa
from rasa import version
from rasa.cli import scaffold, run, train, interactive, shell, test, visualize, data, x
from rasa.cli.arguments.default_arguments import add_logging_options
from rasa.cli.utils import parse_last_positional_argument_as_model_path
from rasa.utils.common import set_log_level
import rasa.core.visualize
import asyncio

if __name__ == "__main__":
    os.chdir('/Users/lidayuan/Documents/edison/rasa/examples/concertbot')
    # rasa.train(domain='domain.yml', config='config.yml', training_files='./data')
    rasa.run(model="models", endpoints="endpoints.yml")
    # loop = asyncio.get_event_loop()
    # loop.run_until_complete(
    #     rasa.core.visualize(config_path="config.yml",
    #                         domain_path="domain.yml",
    #                         stories_path='./data/stories.md',
    #                         nlu_data_path=None,
    #                         output_path="./txt.html",
    #                         max_history=100
    #                         )
    # )
Example #7
0
def rasa_run():
    """rasa run """
    # 创建路径上下文对象
    path_context = PathContext()
    run(model=path_context.model_directory, endpoints=path_context.endpoints_file_path,
        credentials=path_context.credentials_file_path,log_file="./logs/wireless.log")
Example #8
0
# -*- coding:utf-8 -*-
import rasa
from rasa.cli.shell import shell
from rasa.constants import DEFAULT_DOMAIN_PATH, DEFAULT_ENDPOINTS_PATH, DEFAULT_MODELS_PATH
from rasa.core.processor import MessageProcessor
from rasa.core.tracker_store import TrackerStore
from rasa.core.trackers import DialogueStateTracker
from rasa.nlu.registry import component_classes, registered_components

from small_projects.rasa_learn.ep2.train import PROJECT_PATH, CustomPipeline

# component_classes.append(CustomPipeline)
# registered_components[CustomPipeline.name] = CustomPipeline

# class O:
#     model = "/Users/dustyposa/Documents/code/github/goSpider/small_projects/rasa_learn/ep2/models"
#     endpoints = "/Users/dustyposa/Documents/code/github/goSpider/small_projects/rasa_learn/ep2/endpoints.yml"
#     credentials = None
#     enable_api = False
#
#
# shell(O())
from rasa.core.channels import RestInput

# rasa.run(model="/Users/dustyposa/Documents/code/github/goSpider/small_projects/rasa_learn/ep2/models",
#          endpoints="/Users/dustyposa/Documents/code/github/goSpider/small_projects/rasa_learn/ep2/endpoints.yml")
rasa.run(model=str((PROJECT_PATH / DEFAULT_MODELS_PATH)),
         endpoints=str((PROJECT_PATH / DEFAULT_ENDPOINTS_PATH)),
         credentials="./credentials.yml")
from rasa.nlu.registry import Any
Example #9
0
def run():
    import rasa
    rasa.run(model="models", endpoints="endpoints.yml")