def publish_agent(ctx: Context):
"""Publish an agent."""
try_to_load_agent_config(ctx)
check_is_author_logged_in(ctx.agent_config.author)
name = ctx.agent_config.agent_name
agent_config_path = os.path.join(ctx.cwd, DEFAULT_AEA_CONFIG_FILE)
output_tar = os.path.join(ctx.cwd, "{}.tar.gz".format(name))
_compress(output_tar, agent_config_path)
data = {
"name": name,
"description": ctx.agent_config.description,
"version": ctx.agent_config.version,
"connections": ctx.agent_config.connections,
"protocols": ctx.agent_config.protocols,
"skills": ctx.agent_config.skills,
}
path = "/agents/create"
logger.debug("Publishing agent {} to Registry ...".format(name))
resp = request_api("POST",
path,
data=data,
is_auth=True,
filepath=output_tar)
click.echo(
"Successfully published agent {} to the Registry. Public ID: {}".
format(name, resp["public_id"]))
def freeze(ctx: Context):
"""Get the dependencies."""
try_to_load_agent_config(ctx)
for dependency_name, dependency_data in sorted(
ctx.get_dependencies().items(), key=lambda x: x[0]
):
print(dependency_name + dependency_data.get("version", ""))
def _fetch_agent_locally(ctx: Context, public_id: PublicId,
click_context) -> None:
"""
Fetch Agent from local packages.
:param ctx: Context
:param public_id: public ID of agent to be fetched.
:return: None
"""
packages_path = os.path.basename(DEFAULT_REGISTRY_PATH)
source_path = _try_get_item_source_path(packages_path, public_id.author,
"agents", public_id.name)
target_path = os.path.join(ctx.cwd, public_id.name)
if os.path.exists(target_path):
raise click.ClickException(
'Item "{}" already exists in target folder.'.format(
public_id.name))
copy_tree(source_path, target_path)
# add dependencies
ctx.cwd = target_path
try_to_load_agent_config(ctx)
for item_type in ("skill", "connection", "contract", "protocol"):
item_type_plural = "{}s".format(item_type)
required_items = getattr(ctx.agent_config, item_type_plural)
for item_id in required_items:
try:
_add_item(click_context, item_type, item_id)
except SystemExit:
continue
click.echo("Agent {} successfully fetched.".format(public_id.name))
def search(ctx: Context, registry):
"""Search for components in the registry.
If called from an agent directory, it will check
E.g.
aea search connections
aea search --registry skills
"""
if registry:
ctx.set_config("is_registry", True)
else:
# if we are in an agent directory, try to load the configuration file.
# otherwise, use the default path (i.e. 'packages/' in the current directory.)
try:
try_to_load_agent_config(ctx, is_exit_on_except=False)
# path = Path(DEFAULT_AEA_CONFIG_FILE)
# fp = open(str(path), mode="r", encoding="utf-8")
# agent_config = ctx.agent_loader.load(fp)
registry_directory = ctx.agent_config.registry_path
except Exception:
registry_directory = os.path.join(ctx.cwd, DEFAULT_REGISTRY_PATH)
ctx.set_config("registry_directory", registry_directory)
logger.debug("Using registry {}".format(registry_directory))
def _validate_aea(ctx: Context) -> None:
"""
Validate aea project.
:param ctx: the context
"""
try_to_load_agent_config(ctx)
_verify_or_create_private_keys(ctx)
def publish(ctx: Context, registry):
"""Publish Agent to Registry."""
try_to_load_agent_config(ctx)
if not registry:
# TODO: check agent dependencies are available in local packages dir.
_save_agent_locally(ctx)
else:
publish_agent(ctx)
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))
_install_from_requirement(requirement)
else:
logger.debug("Installing all the dependencies...")
dependencies = ctx.get_dependencies()
for name, d in dependencies.items():
_install_dependency(name, d)
def fetch_agent(ctx: Context, public_id: PublicId, click_context) -> None:
"""
Fetch Agent from Registry.
:param public_id: str public ID of desirable Agent.
:return: None
"""
author, name, version = public_id.author, public_id.name, public_id.version
api_path = "/agents/{}/{}/{}".format(author, name, version)
resp = request_api("GET", api_path)
file_url = resp["file"]
filepath = download_file(file_url, ctx.cwd)
extract(filepath, ctx.cwd)
target_folder = os.path.join(ctx.cwd, name)
ctx.cwd = target_folder
try_to_load_agent_config(ctx)
click.echo("Fetching dependencies...")
for item_type in ("connection", "contract", "skill", "protocol"):
item_type_plural = item_type + "s"
# initialize fetched agent with empty folders for custom packages
custom_items_folder = os.path.join(ctx.cwd, item_type_plural)
os.makedirs(custom_items_folder)
config = getattr(ctx.agent_config, item_type_plural)
for item_public_id in config:
try:
_add_item(click_context, item_type, item_public_id)
except Exception as e:
rmtree(target_folder)
raise click.ClickException(
'Unable to fetch dependency for agent "{}", aborting. {}'.
format(name, e))
click.echo("Dependencies successfully fetched.")
click.echo("Agent {} successfully fetched to {}.".format(
name, target_folder))
def publish_agent(ctx: Context):
"""Publish an agent."""
try_to_load_agent_config(ctx)
check_is_author_logged_in(ctx.agent_config.author)
name = ctx.agent_config.agent_name
config_file_source_path = os.path.join(ctx.cwd, DEFAULT_AEA_CONFIG_FILE)
output_tar = os.path.join(ctx.cwd, "{}.tar.gz".format(name))
with tempfile.TemporaryDirectory() as temp_dir:
package_dir = os.path.join(temp_dir, name)
os.makedirs(package_dir)
config_file_target_path = os.path.join(package_dir,
DEFAULT_AEA_CONFIG_FILE)
shutil.copy(config_file_source_path, config_file_target_path)
_compress(output_tar, package_dir)
data = {
"name": name,
"description": ctx.agent_config.description,
"version": ctx.agent_config.version,
"connections": ctx.agent_config.connections,
"contracts": ctx.agent_config.contracts,
"protocols": ctx.agent_config.protocols,
"skills": ctx.agent_config.skills,
}
path = "/agents/create"
logger.debug("Publishing agent {} to Registry ...".format(name))
resp = request_api("POST",
path,
data=data,
is_auth=True,
filepath=output_tar)
click.echo(
"Successfully published agent {} to the Registry. Public ID: {}".
format(name, resp["public_id"]))
def list(ctx: Context):
"""List the installed resources."""
try_to_load_agent_config(ctx)
def get_wealth(ctx: Context, type_):
"""Get the wealth associated with the private key."""
try_to_load_agent_config(ctx)
_verify_or_create_private_keys(ctx)
wealth = _try_get_wealth(ctx, type_)
click.echo(wealth)
def get_address(ctx: Context, type_):
"""Get the address associated with the private key."""
try_to_load_agent_config(ctx)
_verify_or_create_private_keys(ctx)
address = _try_get_address(ctx, type_)
click.echo(address)
def add_key(ctx: Context, type_, file):
"""Add a private key to the wallet."""
try_to_load_agent_config(ctx)
_validate_private_key_path(file, type_)
_try_add_key(ctx, type_, file)
def config(ctx: Context):
"""Read or modify a configuration."""
try_to_load_agent_config(ctx)
def generate(ctx: Context):
"""Generate a resource for the agent."""
try_to_load_agent_config(ctx)
def add(ctx: Context, registry):
"""Add a resource to the agent."""
if registry:
ctx.set_config("is_registry", True)
try_to_load_agent_config(ctx)
def remove(ctx: Context):
"""Remove a resource from the agent."""
try_to_load_agent_config(ctx)
def generate_wealth(ctx: Context, sync, type_):
"""Generate wealth for address on test network."""
try_to_load_agent_config(ctx)
_verify_or_create_private_keys(ctx)
_try_generate_wealth(ctx, type_, sync)
def scaffold(ctx: Context):
"""Scaffold a resource for the agent."""
try_to_load_agent_config(ctx)
def push(ctx: Context, registry):
"""Push item to Registry or save it in local packages."""
try_to_load_agent_config(ctx)
ctx.set_config("registry", registry)