def test_raise_connection_exception_redis_lock_store(monkeypatch: MonkeyPatch): monkeypatch.setattr(rasa.core.lock_store, "RedisLockStore", Mock(side_effect=ConnectionError())) with pytest.raises(ConnectionException): LockStore.create( EndpointConfig(username="******", password="******", type="redis"))
def test_create_lock_store(lock_store: LockStore): conversation_id = "my id 0" # create and lock lock = lock_store.create_lock(conversation_id) lock_store.save_lock(lock) lock = lock_store.get_lock(conversation_id) assert lock assert lock.conversation_id == conversation_id
def create_agent(model: Text, endpoints: Text = None) -> "Agent": """Create an agent instance based on a stored model. Args: model: file path to the stored model endpoints: file path to the used endpoint configuration """ from rasa.core.tracker_store import TrackerStore from rasa.core.utils import AvailableEndpoints 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, )
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).""" import rasa.core.brokers.utils as broker_utils # noinspection PyBroadException # bf mod try: with model.get_model(model_path) as unpacked_model: _, nlu_models = model.get_model_subdirectories(unpacked_model) _interpreters = {} for lang, nlu_model_path in nlu_models.items(): _interpreters[lang] = NaturalLanguageInterpreter.create( nlu_model_path, endpoints.nlu) except Exception: logger.debug(f"Could not load interpreter from '{model_path}'.") _interpreters = {} # /bf mod _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) model_server = endpoints.model if endpoints and endpoints.model else None app.agent = await agent.load_agent( model_path, model_server=model_server, remote_storage=remote_storage, interpreters=_interpreters, generator=endpoints.nlg, tracker_store=_tracker_store, lock_store=_lock_store, action_endpoint=endpoints.action, ) if not app.agent: warnings.warn( "Agent could not be loaded with the provided configuration. " "Load default agent without any model.") app.agent = Agent( interpreters=_interpreters, generator=endpoints.nlg, tracker_store=_tracker_store, action_endpoint=endpoints.action, model_server=model_server, remote_storage=remote_storage, ) return app.agent
async def load_agent_on_start( model_path: Text, endpoints: AvailableEndpoints, remote_storage: Optional[Text], app: Sanic, loop: AbstractEventLoop, ): """Load an agent. Used to be scheduled on server start (hence the `app` and `loop` arguments).""" # noinspection PyBroadException try: with model.get_model(model_path) as unpacked_model: _, nlu_model = model.get_model_subdirectories(unpacked_model) _interpreter = NaturalLanguageInterpreter.create(endpoints.nlu or nlu_model) except Exception: logger.debug(f"Could not load interpreter from '{model_path}'.") _interpreter = None _broker = EventBroker.create(endpoints.event_broker) _tracker_store = TrackerStore.create(endpoints.tracker_store, event_broker=_broker) _lock_store = LockStore.create(endpoints.lock_store) model_server = endpoints.model if endpoints and endpoints.model else None try: app.agent = await agent.load_agent( model_path, model_server=model_server, remote_storage=remote_storage, interpreter=_interpreter, generator=endpoints.nlg, tracker_store=_tracker_store, lock_store=_lock_store, action_endpoint=endpoints.action, ) except Exception as e: rasa.shared.utils.io.raise_warning( f"The model at '{model_path}' could not be loaded. " f"Error: {e}" ) app.agent = None if not app.agent: rasa.shared.utils.io.raise_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, ) logger.info("Rasa server is up and running.") return app.agent
def test_lock_expiration(lock_store: LockStore): conversation_id = "my id 2" lock = lock_store.create_lock(conversation_id) lock_store.save_lock(lock) # issue ticket with long lifetime ticket = lock.issue_ticket(10) assert ticket == 0 assert not lock._ticket_for_ticket_number(ticket).has_expired() # issue ticket with short lifetime ticket = lock.issue_ticket(0.00001) time.sleep(0.00002) assert ticket == 1 assert lock._ticket_for_ticket_number(ticket) is None # newly assigned ticket should get number 1 again assert lock.issue_ticket(10) == 1
def _load_endpoints(self, endpoints: Optional[Text] = None): """加载enpoints文件""" endpoints = AvailableEndpoints.read_endpoints(endpoints) broker = EventBroker.create(endpoints.event_broker) self.tracker_store = TrackerStore.create(endpoints.tracker_store, event_broker=broker) self.generator = endpoints.nlg self.action_endpoint = endpoints.action self.lock_store = LockStore.create(endpoints.lock_store)
async def _load_agent( model_path: Optional[Text] = None, model_server: Optional[EndpointConfig] = None, remote_storage: Optional[Text] = None, endpoints: Optional[AvailableEndpoints] = None, lock_store: Optional[LockStore] = None, ) -> Agent: try: tracker_store = None generator = None action_endpoint = None if endpoints: _broker = rasa.core.brokers.utils.from_endpoint_config( endpoints.event_broker) tracker_store = TrackerStore.find_tracker_store( None, endpoints.tracker_store, _broker) generator = endpoints.nlg action_endpoint = endpoints.action if not lock_store: lock_store = LockStore.find_lock_store(endpoints.lock_store) loaded_agent = await load_agent( model_path, model_server, remote_storage, generator=generator, tracker_store=tracker_store, lock_store=lock_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
async def _load_agent( model_path: Optional[Text] = None, model_server: Optional[EndpointConfig] = None, remote_storage: Optional[Text] = None, endpoints: Optional[AvailableEndpoints] = None, lock_store: Optional[LockStore] = None, ) -> Agent: try: tracker_store = None generator = None action_endpoint = None if endpoints: broker = await EventBroker.create(endpoints.event_broker) tracker_store = TrackerStore.create( endpoints.tracker_store, event_broker=broker ) generator = endpoints.nlg action_endpoint = endpoints.action if not lock_store: lock_store = LockStore.create(endpoints.lock_store) loaded_agent = await rasa.core.agent.load_agent( model_path, model_server, remote_storage, generator=generator, tracker_store=tracker_store, lock_store=lock_store, action_endpoint=action_endpoint, ) except Exception as e: logger.debug(traceback.format_exc()) raise ErrorResponse( HTTPStatus.INTERNAL_SERVER_ERROR, "LoadingError", f"An unexpected error occurred. Error: {e}", ) if not loaded_agent: raise ErrorResponse( HTTPStatus.BAD_REQUEST, "BadRequest", f"Agent with name '{model_path}' could not be loaded.", {"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.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 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 test_serve_ticket(lock_store: LockStore): conversation_id = "my id 1" lock = lock_store.create_lock(conversation_id) lock_store.save_lock(lock) # issue ticket with long lifetime ticket_0 = lock_store.issue_ticket(conversation_id, 10) assert ticket_0 == 0 lock = lock_store.get_lock(conversation_id) assert lock.last_issued == ticket_0 assert lock.now_serving == ticket_0 assert lock.is_someone_waiting() # issue another ticket ticket_1 = lock_store.issue_ticket(conversation_id, 10) # finish serving ticket_0 lock_store.finish_serving(conversation_id, ticket_0) lock = lock_store.get_lock(conversation_id) assert lock.last_issued == ticket_1 assert lock.now_serving == ticket_1 assert lock.is_someone_waiting() # serve second ticket and no one should be waiting lock_store.finish_serving(conversation_id, ticket_1) lock = lock_store.get_lock(conversation_id) assert not lock.is_someone_waiting()
async def load_agent( model_path: Optional[Text] = None, model_server: Optional[EndpointConfig] = None, remote_storage: Optional[Text] = None, endpoints: Optional[AvailableEndpoints] = None, loop: Optional[AbstractEventLoop] = None, ) -> Agent: """Loads agent from server, remote storage or disk. Args: model_path: Path to the model if it's on disk. model_server: Configuration for a potential server which serves the model. remote_storage: URL of remote storage for model. endpoints: Endpoint configuration. loop: Optional async loop to pass to broker creation. Returns: The instantiated `Agent` or `None`. """ from rasa.core.tracker_store import TrackerStore from rasa.core.brokers.broker import EventBroker tracker_store = None lock_store = None generator = None action_endpoint = None http_interpreter = None if endpoints: broker = await EventBroker.create(endpoints.event_broker, loop=loop) tracker_store = TrackerStore.create(endpoints.tracker_store, event_broker=broker) lock_store = LockStore.create(endpoints.lock_store) generator = endpoints.nlg action_endpoint = endpoints.action model_server = endpoints.model if endpoints.model else model_server if endpoints.nlu: http_interpreter = RasaNLUHttpInterpreter(endpoints.nlu) agent = Agent( generator=generator, tracker_store=tracker_store, lock_store=lock_store, action_endpoint=action_endpoint, model_server=model_server, remote_storage=remote_storage, http_interpreter=http_interpreter, ) try: if model_server is not None: return await load_from_server(agent, model_server) elif remote_storage is not None: agent.load_model_from_remote_storage(model_path) elif model_path is not None and os.path.exists(model_path): try: agent.load_model(model_path) except ModelNotFound: rasa.shared.utils.io.raise_warning( f"No valid model found at {model_path}!") else: rasa.shared.utils.io.raise_warning( "No valid configuration given to load agent. " "Agent loaded with no model!") return agent except Exception as e: logger.error(f"Could not load model due to {e}.") return agent