def _find_connection_locally(ctx, connection_name): # check that the provided path points to a proper connection directory -> look for connection.yaml file. # first check in aea dir registry_path = ctx.agent_config.registry_path connection_configuration_filepath = Path(os.path.join(registry_path, "connections", connection_name, DEFAULT_CONNECTION_CONFIG_FILE)) if not connection_configuration_filepath.exists(): # then check in registry registry_path = AEA_DIR connection_configuration_filepath = Path(os.path.join(registry_path, "connections", connection_name, DEFAULT_CONNECTION_CONFIG_FILE)) if not connection_configuration_filepath.exists(): logger.error("Cannot find connection: '{}'.".format(connection_name)) sys.exit(1) # try to load the connection configuration file try: connection_configuration = ctx.connection_loader.load(open(str(connection_configuration_filepath))) logger.info("Connection '{}' supports the following protocols: {}".format(connection_name, connection_configuration.restricted_to_protocols)) except ValidationError as e: logger.error("Connection configuration file not valid: {}".format(str(e))) sys.exit(1) # copy the connection package into the agent's supported connections. src = str(Path(os.path.join(registry_path, "connections", connection_name)).absolute()) dest = os.path.join(ctx.cwd, "connections", connection_name) logger.debug("Copying connection modules. src={} dst={}".format(src, dest)) try: shutil.copytree(src, dest) except Exception as e: logger.error(str(e)) sys.exit(1)
def install(ctx: Context, requirement: Optional[str]): """Install the dependencies.""" _try_to_load_agent_config(ctx) if requirement: logger.debug( "Installing the dependencies in '{}'...".format(requirement)) dependencies = list( map(lambda x: x.strip(), open(requirement).readlines())) else: logger.debug("Installing all the dependencies...") dependencies = ctx.get_dependencies() for d in dependencies: logger.info("Installing {}...".format(d)) try: subp = subprocess.Popen( [sys.executable, "-m", "pip", "install", d]) subp.wait(30.0) assert subp.returncode == 0 except Exception: logger.error( "An error occurred while installing {}. Stopping...".format(d)) sys.exit(1)
def skill(click_context, skill_name): """Add a skill to the agent.""" ctx = cast(Context, click_context.obj) agent_name = ctx.agent_config.agent_name is_registry = ctx.config.get("is_registry") if is_registry: public_id = str(skill_name) skill_name = split_public_id(skill_name)[1] logger.info("Adding skill '{}' to the agent '{}'...".format(skill_name, agent_name)) # check if we already have a skill with the same name logger.debug("Skills already supported by the agent: {}".format(ctx.agent_config.skills)) if skill_name in ctx.agent_config.skills: logger.error("A skill with name '{}' already exists. Aborting...".format(skill_name)) sys.exit(1) # find and add protocol if is_registry: # fetch from Registry fetch_package('skill', public_id=public_id, cwd=ctx.cwd) else: _find_skill_locally(ctx, skill_name, click_context) # make the 'skills' folder a Python package. skills_init_module = os.path.join(ctx.cwd, "skills", "__init__.py") logger.debug("Creating {}".format(skills_init_module)) Path(skills_init_module).touch(exist_ok=True) # add the skill to the configurations. logger.debug("Registering the skill into {}".format(DEFAULT_AEA_CONFIG_FILE)) ctx.agent_config.skills.add(skill_name) ctx.agent_loader.dump(ctx.agent_config, open(os.path.join(ctx.cwd, DEFAULT_AEA_CONFIG_FILE), "w"))
def delete(ctx: Context, agent_name): """Delete an agent.""" path = Path(agent_name) # check that the target folder is an AEA project. cwd = os.getcwd() try: os.chdir(agent_name) fp = open(DEFAULT_AEA_CONFIG_FILE, mode="r", encoding="utf-8") ctx.agent_config = ctx.agent_loader.load(fp) _try_to_load_agent_config(ctx) except Exception: logger.error("The name provided is not an AEA project.") sys.exit(1) finally: os.chdir(cwd) logger.info("Deleting agent project directory '/{}'...".format(path)) # delete the agent's directory try: shutil.rmtree(path, ignore_errors=False) except OSError: logger.error( "An error occurred while deleting the agent directory. Aborting..." ) sys.exit(1)
def protocol(ctx: Context, protocol_name): """Remove a protocol from the agent.""" agent_name = ctx.agent_config.agent_name logger.info( "Removing protocol {protocol_name} from the agent {agent_name}...". format(agent_name=agent_name, protocol_name=protocol_name)) if protocol_name not in ctx.agent_config.protocols: logger.error("Protocol '{}' not found.".format(protocol_name)) exit(-1) protocol_folder = os.path.join("protocols", protocol_name) try: shutil.rmtree(protocol_folder) except BaseException: logger.exception("An error occurred.") exit(-1) # removing the protocol to the configurations. logger.debug( "Removing the protocol from {}".format(DEFAULT_AEA_CONFIG_FILE)) if protocol_name in ctx.agent_config.protocols: ctx.agent_config.protocols.remove(protocol_name) ctx.agent_loader.dump(ctx.agent_config, open(DEFAULT_AEA_CONFIG_FILE, "w"))
def connection(ctx: Context, connection_name): """Remove a connection from the agent.""" agent_name = ctx.agent_config.agent_name logger.info( "Removing connection {connection_name} from the agent {agent_name}...". format(agent_name=agent_name, connection_name=connection_name)) if connection_name not in ctx.agent_config.connections: logger.error("Connection '{}' not found.".format(connection_name)) exit(-1) connection_folder = os.path.join("connections", connection_name) try: shutil.rmtree(connection_folder) except BaseException: logger.exception( "An error occurred while deleting '{}'.".format(connection_folder)) exit(-1) # removing the connection to the configurations. logger.debug( "Removing the connection from {}".format(DEFAULT_AEA_CONFIG_FILE)) if connection_name in ctx.agent_config.connections: ctx.agent_config.connections.remove(connection_name) ctx.agent_loader.dump(ctx.agent_config, open(DEFAULT_AEA_CONFIG_FILE, "w"))
def connection(click_context, connection_name): """Add a connection to the configuration file.""" ctx = cast(Context, click_context.obj) agent_name = ctx.agent_config.agent_name is_registry = ctx.config.get("is_registry") if is_registry: public_id = str(connection_name) connection_name = split_public_id(connection_name)[1] logger.info("Adding connection '{}' to the agent '{}'...".format(connection_name, agent_name)) # check if we already have a connection with the same name logger.debug("Connections already supported by the agent: {}".format(ctx.agent_config.connections)) if connection_name in ctx.agent_config.connections: logger.error("A connection with name '{}' already exists. Aborting...".format(connection_name)) sys.exit(1) # find and add connection if is_registry: # fetch from Registry fetch_package('connection', public_id=public_id, cwd=ctx.cwd) else: _find_connection_locally(ctx, connection_name) # make the 'connections' folder a Python package. connections_init_module = os.path.join(ctx.cwd, "connections", "__init__.py") logger.debug("Creating {}".format(connections_init_module)) Path(connections_init_module).touch(exist_ok=True) # add the connections to the configurations. logger.debug("Registering the connection into {}".format(DEFAULT_AEA_CONFIG_FILE)) ctx.agent_config.connections.add(connection_name) ctx.agent_loader.dump(ctx.agent_config, open(os.path.join(ctx.cwd, DEFAULT_AEA_CONFIG_FILE), "w"))
def skill(click_context, skill_name): """Add a skill to the agent.""" ctx = cast(Context, click_context.obj) agent_name = ctx.agent_config.agent_name logger.debug("Adding skill {} to the agent {}...".format(skill_name, agent_name)) # check if we already have a skill with the same name logger.debug("Skills already supported by the agent: {}".format(ctx.agent_config.skills)) if skill_name in ctx.agent_config.skills: logger.error("A skill with name '{}' already exists. Aborting...".format(skill_name)) exit(-1) # check that the provided path points to a proper skill directory -> look for skill.yaml file. # first check in aea dir registry_path = ctx.agent_config.registry_path skill_configuration_filepath = Path(os.path.join(registry_path, "skills", skill_name, DEFAULT_SKILL_CONFIG_FILE)) if not skill_configuration_filepath.exists(): # then check in registry registry_path = AEA_DIR skill_configuration_filepath = Path(os.path.join(registry_path, "skills", skill_name, DEFAULT_SKILL_CONFIG_FILE)) if not skill_configuration_filepath.exists(): logger.error("Cannot find skill: '{}'.".format(skill_name)) exit(-1) # try to load the skill configuration file try: skill_configuration = ctx.skill_loader.load(open(str(skill_configuration_filepath))) except ValidationError as e: logger.error("Skill configuration file not valid: {}".format(str(e))) exit(-1) # copy the skill package into the agent's supported skills. src = str(Path(os.path.join(registry_path, "skills", skill_name)).absolute()) dest = os.path.join(ctx.cwd, "skills", skill_name) logger.info("Copying skill modules. src={} dst={}".format(src, dest)) try: shutil.copytree(src, dest) except Exception as e: logger.error(str(e)) exit(-1) # make the 'skills' folder a Python package. skills_init_module = os.path.join(ctx.cwd, "skills", "__init__.py") logger.debug("Creating {}".format(skills_init_module)) Path(skills_init_module).touch(exist_ok=True) # check for not supported protocol, and add it. for protocol_name in skill_configuration.protocols: if protocol_name not in ctx.agent_config.protocols: logger.info("Adding protocol '{}' to the agent...".format(protocol_name)) click_context.invoke(protocol, protocol_name=protocol_name) # add the skill to the configurations. logger.debug("Registering the skill into {}".format(DEFAULT_AEA_CONFIG_FILE)) ctx.agent_config.skills.add(skill_name) ctx.agent_loader.dump(ctx.agent_config, open(os.path.join(ctx.cwd, DEFAULT_AEA_CONFIG_FILE), "w"))
def delete(ctx: Context, agent_name): """Delete an agent.""" path = Path(agent_name) logger.info("Deleting agent's directory in '{}'...".format(path)) # delete the agent's directory try: shutil.rmtree(path, ignore_errors=False) except OSError: logger.error("An error occurred while deleting the agent directory. Aborting...") exit(-1)
def run(click_context, connection_names: List[str], env_file: str, install_deps: bool): """Run the agent.""" ctx = cast(Context, click_context.obj) _try_to_load_agent_config(ctx) _load_env_file(env_file) agent_name = cast(str, ctx.agent_config.agent_name) _verify_or_create_private_keys(ctx) _verify_ledger_apis_access() private_key_paths = dict([(identifier, config.path) for identifier, config in ctx.agent_config.private_key_paths.read_all()]) ledger_api_configs = dict([ (identifier, (config.addr, config.port)) for identifier, config in ctx.agent_config.ledger_apis.read_all() ]) wallet = Wallet(private_key_paths) ledger_apis = LedgerApis(ledger_api_configs) connection_names = [ctx.agent_config.default_connection ] if connection_names is None else connection_names connections = [] _try_to_load_protocols(ctx) try: for connection_name in connection_names: connection = _setup_connection(connection_name, wallet.public_keys[FETCHAI], ctx) connections.append(connection) except AEAConfigException as e: logger.error(str(e)) sys.exit(1) if install_deps: if Path("requirements.txt").exists(): click_context.invoke(install, requirement="requirements.txt") else: click_context.invoke(install) agent = AEA(agent_name, connections, wallet, ledger_apis, resources=Resources(str(Path(".")))) try: agent.start() except KeyboardInterrupt: logger.info("Interrupted.") # pragma: no cover except Exception as e: logger.exception(e) sys.exit(1) finally: agent.stop()
def connection(click_context, connection_name): """Add a connection to the configuration file.""" ctx = cast(Context, click_context.obj) agent_name = ctx.agent_config.agent_name logger.debug("Adding connection {} to the agent {}...".format(connection_name, agent_name)) # check if we already have a connection with the same name logger.debug("Connection already supported by the agent: {}".format(ctx.agent_config.connections)) if connection_name in ctx.agent_config.connections: logger.error("A connection with name '{}' already exists. Aborting...".format(connection_name)) exit(-1) # check that the provided path points to a proper connection directory -> look for connection.yaml file. # first check in aea dir registry_path = ctx.agent_config.registry_path connection_configuration_filepath = Path(os.path.join(registry_path, "connections", connection_name, DEFAULT_CONNECTION_CONFIG_FILE)) if not connection_configuration_filepath.exists(): # then check in registry registry_path = AEA_DIR connection_configuration_filepath = Path(os.path.join(registry_path, "connections", connection_name, DEFAULT_CONNECTION_CONFIG_FILE)) if not connection_configuration_filepath.exists(): logger.error("Cannot find connection: '{}'.".format(connection_name)) exit(-1) # try to load the connection configuration file try: connection_configuration = ctx.connection_loader.load(open(str(connection_configuration_filepath))) logger.info("Connection supports the following protocols: {}".format(connection_configuration.supported_protocols)) except ValidationError as e: logger.error("Connection configuration file not valid: {}".format(str(e))) exit(-1) # copy the connection package into the agent's supported connections. src = str(Path(os.path.join(registry_path, "connections", connection_name)).absolute()) dest = os.path.join(ctx.cwd, "connections", connection_name) logger.info("Copying connection modules. src={} dst={}".format(src, dest)) try: shutil.copytree(src, dest) except Exception as e: logger.error(str(e)) exit(-1) # make the 'connections' folder a Python package. connections_init_module = os.path.join(ctx.cwd, "connections", "__init__.py") logger.debug("Creating {}".format(connections_init_module)) Path(connections_init_module).touch(exist_ok=True) # add the connections to the configurations. logger.debug("Registering the connection into {}".format(DEFAULT_AEA_CONFIG_FILE)) ctx.agent_config.connections.add(connection_name) ctx.agent_loader.dump(ctx.agent_config, open(os.path.join(ctx.cwd, DEFAULT_AEA_CONFIG_FILE), "w"))
def protocol(click_context, protocol_name): """Add a protocol to the agent.""" ctx = cast(Context, click_context.obj) agent_name = cast(str, ctx.agent_config.agent_name) logger.debug("Adding protocol {} to the agent {}...".format(protocol_name, agent_name)) # check if we already have a protocol with the same name logger.debug("Protocols already supported by the agent: {}".format(ctx.agent_config.protocols)) if protocol_name in ctx.agent_config.protocols: logger.error("A protocol with name '{}' already exists. Aborting...".format(protocol_name)) exit(-1) # check that the provided path points to a proper protocol directory -> look for protocol.yaml file. # first check in aea dir registry_path = ctx.agent_config.registry_path protocol_configuration_filepath = Path(os.path.join(registry_path, "protocols", protocol_name, DEFAULT_PROTOCOL_CONFIG_FILE)) if not protocol_configuration_filepath.exists(): # then check in registry registry_path = AEA_DIR protocol_configuration_filepath = Path(os.path.join(registry_path, "protocols", protocol_name, DEFAULT_PROTOCOL_CONFIG_FILE)) if not protocol_configuration_filepath.exists(): logger.error("Cannot find protocol: '{}'.".format(protocol_name)) exit(-1) # try to load the protocol configuration file try: protocol_configuration = ctx.protocol_loader.load(open(str(protocol_configuration_filepath))) logger.info("Protocol available: {}".format(protocol_configuration.name)) except ValidationError as e: logger.error("Protocol configuration file not valid: {}".format(str(e))) exit(-1) return # copy the protocol package into the agent's supported connections. src = str(Path(os.path.join(registry_path, "protocols", protocol_name)).absolute()) dest = os.path.join(ctx.cwd, "protocols", protocol_name) logger.info("Copying protocol modules. src={} dst={}".format(src, dest)) try: shutil.copytree(src, dest) except Exception as e: logger.error(str(e)) exit(-1) # make the 'protocols' folder a Python package. logger.debug("Creating {}".format(os.path.join(agent_name, "protocols", "__init__.py"))) Path(os.path.join(ctx.cwd, "protocols", "__init__.py")).touch(exist_ok=True) # add the protocol to the configurations. logger.debug("Registering the protocol into {}".format(DEFAULT_AEA_CONFIG_FILE)) ctx.agent_config.protocols.add(protocol_name) ctx.agent_loader.dump(ctx.agent_config, open(os.path.join(ctx.cwd, DEFAULT_AEA_CONFIG_FILE), "w"))
def protocol(ctx: Context, protocol_name: str): """Add a protocol scaffolding to the configuration file and agent.""" # check if we already have a protocol with the same name logger.debug("Protocols already supported by the agent: {}".format( ctx.agent_config.protocols)) if protocol_name in ctx.agent_config.protocols: logger.error( "A protocol with name '{}' already exists. Aborting...".format( protocol_name)) exit(-1) return try: # create the 'protocols' folder if it doesn't exist: if not os.path.exists("protocols"): os.makedirs("protocols") # create the protocol folder dest = Path(os.path.join("protocols", protocol_name)) # copy the skill package into the agent's supported skills. src = Path(os.path.join(AEA_DIR, "protocols", "scaffold")) logger.info("Copying protocol modules. src={} dst={}".format( src, dest)) try: shutil.copytree(src, dest) except Exception as e: logger.error(e) exit(-1) # add the protocol to the configurations. logger.info( "Registering the protocol into {}".format(DEFAULT_AEA_CONFIG_FILE)) ctx.agent_config.protocols.add(protocol_name) ctx.agent_loader.dump( ctx.agent_config, open(os.path.join(ctx.cwd, DEFAULT_AEA_CONFIG_FILE), "w")) except OSError: logger.error("Directory already exist. Aborting...") exit(-1) except ValidationError as e: logger.error(str(e)) shutil.rmtree(protocol_name, ignore_errors=True) exit(-1) except Exception as e: logger.exception(e) shutil.rmtree(protocol_name, ignore_errors=True) exit(-1)
def create(click_context, agent_name): """Create an agent.""" ctx = cast(Context, click_context.obj) path = Path(agent_name) logger.info("Initializing AEA project '{}'".format(agent_name)) logger.info("Creating project directory '/{}'".format(agent_name)) # create the agent's directory try: path.mkdir(exist_ok=False) # create a config file inside it logger.info("Creating config file {}".format(DEFAULT_AEA_CONFIG_FILE)) config_file = open(os.path.join(agent_name, DEFAULT_AEA_CONFIG_FILE), "w") agent_config = AgentConfig(agent_name=agent_name, aea_version=aea.__version__, authors="", version="v1", license="", url="", registry_path=DEFAULT_REGISTRY_PATH, description="") agent_config.default_connection = DEFAULT_CONNECTION ctx.agent_loader.dump(agent_config, config_file) # next commands must be done from the agent's directory -> overwrite ctx.cwd ctx.agent_config = agent_config ctx.cwd = agent_config.agent_name logger.info("Default connections:") click_context.invoke(connection, connection_name=DEFAULT_CONNECTION) logger.info("Default skills:") click_context.invoke(skill, skill_name=DEFAULT_SKILL) except OSError: logger.error("Directory already exist. Aborting...") sys.exit(1) except ValidationError as e: logger.error(str(e)) shutil.rmtree(agent_name, ignore_errors=True) sys.exit(1) except Exception as e: logger.exception(e) shutil.rmtree(agent_name, ignore_errors=True) sys.exit(1)
def run(ctx: Context, connection_name: str): """Run the agent.""" _try_to_load_agent_config(ctx) agent_name = cast(str, ctx.agent_config.agent_name) private_key_pem_path = cast(str, ctx.agent_config.private_key_pem_path) if private_key_pem_path == "": private_key_pem_path = _create_temporary_private_key_pem_path() else: _try_validate_private_key_pem_path(private_key_pem_path) crypto = Crypto(private_key_pem_path=private_key_pem_path) public_key = crypto.public_key connection_name = ctx.agent_config.default_connection if connection_name is None else connection_name _try_to_load_protocols(ctx) try: connection = _setup_connection(connection_name, public_key, ctx) except AEAConfigException as e: logger.error(str(e)) exit(-1) return logger.debug("Installing all the dependencies...") for d in ctx.get_dependencies(): logger.debug("Installing {}...".format(d)) try: subp = subprocess.Popen( [sys.executable, "-m", "pip", "install", d]) subp.wait(30.0) except Exception: logger.error( "An error occurred while installing {}. Stopping...".format(d)) exit(-1) mailbox = MailBox(connection) agent = AEA(agent_name, mailbox, private_key_pem_path=private_key_pem_path, directory=str(Path("."))) try: agent.start() except KeyboardInterrupt: logger.info("Interrupted.") except Exception as e: logger.exception(e) finally: agent.stop()
def skill(ctx: Context, skill_name): """Remove a skill from the agent.""" agent_name = ctx.agent_config.agent_name logger.info("Removing skill '{skill_name}' from the agent '{agent_name}'..." .format(agent_name=agent_name, skill_name=skill_name)) if skill_name not in ctx.agent_config.skills: logger.error("The skill '{}' is not supported.".format(skill_name)) sys.exit(1) skill_folder = os.path.join("skills", skill_name) try: shutil.rmtree(skill_folder) except BaseException: logger.exception("An error occurred.") sys.exit(1) # removing the protocol to the configurations. logger.debug("Removing the skill from {}".format(DEFAULT_AEA_CONFIG_FILE)) if skill_name in ctx.agent_config.skills: ctx.agent_config.skills.remove(skill_name) ctx.agent_loader.dump(ctx.agent_config, open(DEFAULT_AEA_CONFIG_FILE, "w"))
def launch(click_context, agents: List[str]): """Launch many agents.""" agents_directories = list(map(Path, list(OrderedDict.fromkeys(agents)))) agent_processes = [ Process(target=_run_agent, args=(click_context, agent_directory)) for agent_directory in agents_directories ] failed = 0 try: for agent_directory, agent_process in zip(agents_directories, agent_processes): agent_process.start() logger.info("Agent {} started...".format(agent_directory.name)) for agent_process in agent_processes: agent_process.join() failed |= (agent_process.exitcode if agent_process.exitcode is not None else 1) except KeyboardInterrupt: # at this point, the keyboard interrupt has been propagated # to all the child process, hence we just need to 'join' the processes. for agent_directory, agent_process in zip(agents_directories, agent_processes): logger.info("Waiting for agent {} to shut down...".format( agent_directory.name)) agent_process.join(5.0) if agent_process.is_alive(): logger.info("Killing agent {}...".format(agent_directory.name)) agent_process.kill() failed = 1 else: logger.info("Agent {} terminated with exit code {}".format( agent_directory.name, agent_process.exitcode)) failed |= (agent_process.exitcode if agent_process.exitcode is not None else 1) except Exception as e: logger.exception(e) sys.exit(1) sys.exit(1) if failed else sys.exit(0)
def _launch_subprocesses(click_context: click.Context, agents: List[Path]): """ Launch many agents using subprocesses. :param agents: list of paths to agent projects. :return: None """ ctx = cast(Context, click_context.obj) processes = [] failed = 0 for agent_directory in agents: process = Popen( # nosec [sys.executable, "-m", "aea.cli", "-v", ctx.verbosity, "run"], cwd=str(agent_directory), ) logger.info("Agent {} started...".format(agent_directory.name)) processes.append(process) try: for process in processes: process.wait() except KeyboardInterrupt: logger.info("Keyboard interrupt detected.") finally: for agent_directory, process in zip(agents, processes): result = process.poll() if result is None: try: process.wait() except (subprocess.TimeoutExpired, KeyboardInterrupt): logger.info("Force shutdown {}...".format( agent_directory.name)) process.kill() logger.info("Agent {} terminated with exit code {}".format( agent_directory.name, process.returncode)) failed |= process.returncode if process.returncode is not None else -1 sys.exit(failed)
def create(click_context, agent_name): """Create an agent.""" ctx = cast(Context, click_context.obj) path = Path(agent_name) logger.info("Creating agent's directory in '{}'".format(path)) # create the agent's directory try: path.mkdir(exist_ok=False) # create a config file inside it config_file = open(os.path.join(agent_name, DEFAULT_AEA_CONFIG_FILE), "w") agent_config = AgentConfig(agent_name=agent_name, aea_version=aea.__version__, authors="", version="v1", license="", url="", registry_path="../packages", private_key_pem_path="") agent_config.default_connection = DEFAULT_CONNECTION ctx.agent_loader.dump(agent_config, config_file) logger.info("Created config file {}".format(DEFAULT_AEA_CONFIG_FILE)) # next commands must be done from the agent's directory -> overwrite ctx.cwd ctx.agent_config = agent_config ctx.cwd = agent_config.agent_name logger.info("Adding default connection '{}' to the agent...".format(DEFAULT_CONNECTION)) click_context.invoke(connection, connection_name=DEFAULT_CONNECTION) logger.info("Adding default skill '{}' to the agent...".format(DEFAULT_SKILL)) click_context.invoke(skill, skill_name=DEFAULT_SKILL) except OSError: logger.error("Directory already exist. Aborting...") exit(-1) except ValidationError as e: logger.error(str(e)) shutil.rmtree(agent_name, ignore_errors=True) exit(-1) except Exception as e: logger.exception(e) shutil.rmtree(agent_name, ignore_errors=True) exit(-1)
def _scaffold_item(ctx: Context, item_type, item_name): """Add an item scaffolding to the configuration file and agent.""" existing_item_list = getattr(ctx.agent_config, "{}s".format(item_type)) loader = getattr(ctx, "{}_loader".format(item_type)) default_config_filename = globals()["DEFAULT_{}_CONFIG_FILE".format( item_type.upper())] item_type_plural = item_type + "s" # check if we already have an item with the same name logger.debug("{} already supported by the agent: {}".format( item_type_plural, existing_item_list)) if item_name in existing_item_list: logger.error("A {} with name '{}' already exists. Aborting...".format( item_type, item_name)) sys.exit(1) try: agent_name = ctx.agent_config.agent_name logger.info("Adding {} scaffold '{}' to the agent '{}'...".format( item_type, item_name, agent_name)) Path(item_type_plural).mkdir(exist_ok=True) # create the connection folder dest = Path(os.path.join(item_type_plural, item_name)) # copy the skill package into the agent's supported skills. src = Path(os.path.join(AEA_DIR, item_type_plural, "scaffold")) logger.debug("Copying {} modules. src={} dst={}".format( item_type, src, dest)) shutil.copytree(src, dest) # add the connection to the configurations. logger.debug("Registering the {} into {}".format( item_type, DEFAULT_AEA_CONFIG_FILE)) existing_item_list.add(item_name) ctx.agent_loader.dump( ctx.agent_config, open(os.path.join(ctx.cwd, DEFAULT_AEA_CONFIG_FILE), "w")) # ensure the name in the yaml and the name of the folder are the same config_filepath = os.path.join(ctx.cwd, item_type_plural, item_name, default_config_filename) config = loader.load(open(str(config_filepath))) config.name = item_name loader.dump(config, open(config_filepath, "w")) except FileExistsError: logger.error( "A {} with this name already exists. Please choose a different name and try again." .format(item_type)) sys.exit(1) except ValidationError: logger.error("Error when validating the skill configuration file.") shutil.rmtree(os.path.join(item_type_plural, item_name), ignore_errors=True) sys.exit(1) except Exception as e: logger.exception(e) shutil.rmtree(os.path.join(item_type_plural, item_name), ignore_errors=True) sys.exit(1)
def gui(ctx: Context, port): """Run the CLI GUI.""" import aea.cli_gui # pragma: no cover logger.info( "Running the GUI.....(press Ctrl+C to exit)") # pragma: no cover aea.cli_gui.run(port) # pragma: no cover