def delete(ctx):
"""Delete project.
Uses [Caching](/references/polyaxon-cli/#caching)
"""
owner, project_name = get_project_or_local(ctx.obj.get("project"))
if not click.confirm("Are sure you want to delete project `{}/{}`".format(
owner, project_name)):
click.echo("Existing without deleting project.")
sys.exit(1)
try:
polyaxon_client = PolyaxonClient()
response = polyaxon_client.projects_v1.delete_project(
owner, project_name)
local_project = ProjectManager.get_config()
if local_project and (owner, project_name) == (
local_project.user,
local_project.name,
):
# Purge caching
ProjectManager.purge()
except (ApiException, HTTPError) as e:
handle_cli_error(e,
message="Could not delete project `{}/{}`.".format(
owner, project_name))
sys.exit(1)
if response.status_code == 204:
Printer.print_success("Project `{}/{}` was delete successfully".format(
owner, project_name))
def get(ctx):
"""Get info for current project, by project_name, or user/project_name.
Uses [Caching](/references/polyaxon-cli/#caching)
Examples:
To get current project:
\b
```bash
$ polyaxon project get
```
To get a project by name
\b
```bash
$ polyaxon project get user/project
```
"""
owner, project_name = get_project_or_local(ctx.obj.get("project"))
try:
polyaxon_client = PolyaxonClient()
response = polyaxon_client.projects_v1.get_project(owner, project_name)
except (ApiException, HTTPError) as e:
handle_cli_error(
e, message="Could not get project `{}`.".format(project_name))
sys.exit(1)
get_project_details(response)
def ci(ctx, enable, disable): # pylint:disable=assign-to-new-keyword
"""Enable/Disable CI on this project.
Uses [Caching](/references/polyaxon-cli/#caching)
Example:
\b
```bash
$ polyaxon project ci --enable
```
\b
```bash
$ polyaxon project ci --disable
```
"""
owner, project_name = get_project_or_local(ctx.obj.get("project"))
polyaxon_client = PolyaxonClient()
def enable_ci():
try:
polyaxon_client.projects_v1.enable_ci(owner, project_name)
except (ApiException, HTTPError) as e:
handle_cli_error(
e,
message="Could not enable CI on project `{}`.".format(
project_name))
sys.exit(1)
Printer.print_success(
"Polyaxon CI was successfully enabled on project: `{}`.".format(
project_name))
def disable_ci():
try:
polyaxon_client.projects_v1.disable_ci(owner, project_name)
except (ApiException, HTTPError) as e:
handle_cli_error(
e,
message="Could not disable CI on project `{}`.".format(
project_name))
sys.exit(1)
Printer.print_success(
"Polyaxon CI was successfully disabled on project: `{}`.".format(
project_name))
if enable:
enable_ci()
if disable:
disable_ci()
def update(ctx, name, description, private):
"""Update project.
Uses [Caching](/references/polyaxon-cli/#caching)
Example:
\b
```bash
$ polyaxon update foobar --description="Image Classification with DL using TensorFlow"
```
\b
```bash
$ polyaxon update mike1/foobar --description="Image Classification with DL using TensorFlow"
```
\b
```bash
$ polyaxon update --tags="foo, bar"
```
"""
owner, project_name = get_project_or_local(ctx.obj.get("project"))
update_dict = {}
if name:
update_dict["name"] = name
if description:
update_dict["description"] = description
if private is not None:
update_dict["is_public"] = not private
if not update_dict:
Printer.print_warning(
"No argument was provided to update the project.")
sys.exit(1)
try:
polyaxon_client = PolyaxonClient()
response = polyaxon_client.projects_v1.patch_project(
owner, project_name, update_dict)
except (ApiException, HTTPError) as e:
handle_cli_error(
e, message="Could not update project `{}`.".format(project_name))
sys.exit(1)
Printer.print_success("Project updated.")
get_project_details(response)
def download(ctx, commit):
"""Download code of the current project."""
user, project_name = get_project_or_local(ctx.obj.get("project"))
try:
polyaxon_client = PolyaxonClient()
polyaxon_client.projects_v1.download_repo(user,
project_name,
commit=commit)
except (ApiException, HTTPError) as e:
handle_cli_error(
e,
message="Could not download code for project `{}`.".format(
project_name))
sys.exit(1)
Printer.print_success("Files downloaded.")
def bookmark(ctx):
"""Bookmark project.
Uses [Caching](/references/polyaxon-cli/#caching)
"""
owner, project_name = get_project_or_local(ctx.obj.get("project"))
try:
polyaxon_client = PolyaxonClient()
polyaxon_client.projects_v1.bookmark_project(owner, project_name)
except (ApiException, HTTPError) as e:
handle_cli_error(e,
message="Could not bookmark project `{}/{}`.".format(
owner, project_name))
sys.exit(1)
Printer.print_success("Project `{}/{}` is bookmarked.".format(
owner, project_name))
def init(project, polyaxonfile, purge):
"""Initialize a new polyaxonfile specification."""
owner, project_name = get_project_or_local(project)
try:
polyaxon_client = PolyaxonClient()
project_config = polyaxon_client.projects_v1.get_project(
owner, project_name)
except (ApiException, HTTPError) as e:
Printer.print_error(
"Make sure you have a project with this name `{}`".format(project))
handle_cli_error(
e,
message="You can a create new project with this command: "
"polyaxon project create "
"--name={} [--description=...] [--tags=...]".format(project_name),
)
sys.exit(1)
if purge:
ProjectManager.purge()
IgnoreManager.purge()
init_project = False
if ProjectManager.is_initialized():
local_project = ProjectManager.get_config()
click.echo(
"Warning! This project is already initialized with the following project:"
)
with indentation.indent(4):
indentation.puts("User: {}".format(local_project.user))
indentation.puts("Project: {}".format(local_project.name))
if click.confirm("Would you like to override this current config?",
default=False):
init_project = True
else:
init_project = True
if init_project:
ProjectManager.purge()
config = polyaxon_client.api_client.sanitize_for_serialization(
project_config)
ProjectManager.set_config(config, init=True)
Printer.print_success("Project was initialized")
else:
Printer.print_header("Project config was not changed.")
init_ignore = False
if IgnoreManager.is_initialized():
click.echo("Warning! Found a .polyaxonignore file.")
if click.confirm("Would you like to override it?", default=False):
init_ignore = True
else:
init_ignore = True
if init_ignore:
IgnoreManager.init_config()
Printer.print_success("New .polyaxonignore file was created.")
else:
Printer.print_header(".polyaxonignore file was not changed.")
if polyaxonfile:
create_polyaxonfile()
create_debug_polyaxonfile()
def get_project_run_or_local(project=None, run_uuid=None):
user, project_name = get_project_or_local(project)
run_uuid = get_run_or_local(run_uuid)
return user, project_name, run_uuid
def ls(ctx, io, query, sort, limit, offset):
"""List runs for this project.
Uses [Caching](/references/polyaxon-cli/#caching)
Examples:
Get all runs:
\b
```bash
$ polyaxon project runs
```
Get all runs with with status {created or running}, and
creation date between 2018-01-01 and 2018-01-02, and params activation equal to sigmoid
and metric loss less or equal to 0.2
\b
```bash
$ polyaxon project runs \
-q "status:created|running, started_at:2018-01-01..2018-01-02, \
params.activation:sigmoid, metric.loss:<=0.2"
```
Get all runs sorted by update date
\b
```bash
$ polyaxon project runs -s "-updated_at"
```
"""
owner, project_name = get_project_or_local(ctx.obj.get("project"))
try:
polyaxon_client = PolyaxonClient()
params = get_query_params(limit=limit,
offset=offset,
query=query,
sort=sort)
response = polyaxon_client.runs_v1.list_runs(owner=owner,
project=project_name,
**params)
except (ApiException, HTTPError) as e:
handle_cli_error(e,
message="Could not get runs for project `{}`.".format(
project_name))
sys.exit(1)
meta = get_meta_response(response)
if meta:
Printer.print_header("Experiments for project `{}/{}`.".format(
owner, project_name))
Printer.print_header("Navigation:")
dict_tabulate(meta)
else:
Printer.print_header("No runs found for project `{}/{}`.".format(
owner, project_name))
objects = [Printer.add_status_color(o.to_dict()) for o in response.results]
if io:
objects = get_runs_with_keys(objects=objects,
params_keys=["inputs", "outputs"])
objects = list_dicts_to_tabulate(
objects,
exclude_attrs=[
"owner",
"project",
"description",
"content",
"deleted",
"readme",
"run_env",
],
)
else:
objects = list_dicts_to_tabulate(
objects,
exclude_attrs=[
"owner",
"project",
"description",
"content",
"deleted",
"readme",
"run_env",
"inputs",
"outputs",
],
)
if objects:
Printer.print_header("Runs:")
objects.pop("project_name", None)
dict_tabulate(objects, is_list_dict=True)
def git(ctx, url, private, sync): # pylint:disable=assign-to-new-keyword
"""Set/Sync git repo on this project. TODO
Uses [Caching](/references/polyaxon-cli/#caching)
Example:
\b
```bash
$ polyaxon project git --url=https://github.com/polyaxon/polyaxon-quick-start
```
\b
```bash
$ polyaxon project git --url=https://github.com/polyaxon/polyaxon-quick-start --private
```
"""
user, project_name = get_project_or_local(ctx.obj.get("project"))
def git_set_url():
if private:
click.echo(
'\nSetting a private git repo "{}" on project: {} ...\n'.
format(url, project_name))
else:
click.echo(
'\nSetting a public git repo "{}" on project: {} ...\n'.format(
url, project_name))
try:
PolyaxonClient().projects_v1.set_repo(user, project_name, url,
not private)
except (ApiException, HTTPError) as e:
handle_cli_error(
e,
message="Could not set git repo on project `{}`.".format(
project_name),
)
sys.exit(1)
Printer.print_success(
"Project was successfully initialized with `{}`.".format(url))
def git_sync_repo():
try:
response = PolyaxonClient().projects_v1.sync_repo(
user, project_name)
except (ApiException, HTTPError) as e:
handle_cli_error(
e,
message="Could not sync git repo on project `{}`.".format(
project_name),
)
sys.exit(1)
click.echo(response.status_code)
Printer.print_success(
"Project was successfully synced with latest changes.")
if url:
git_set_url()
if sync:
git_sync_repo()
def run(
ctx,
project,
polyaxonfile,
name,
tags,
description,
upload,
log,
local,
conda_env,
params,
profile,
nocache,
):
"""Run polyaxonfile specification.
Examples:
\b
```bash
$ polyaxon run -f file -f file_override ...
```
Upload before running
\b
```bash
$ polyaxon run -f file -u
```
Run and set description and tags for this run
\b
```bash
$ polyaxon run -f file -u --description="Description of the current run" --tags="foo, bar, moo"
```
Run and set a unique name for this run
\b
```bash
polyaxon run --name=foo
```
Run for a specific project
\b
```bash
$ polyaxon run -p project1 -f file.yaml
```
Run with updated params
\b
```bash
$ polyaxon run -p project1 -f file.yaml -P param1=234.2 -P param2=relu
```
"""
specification = check_polyaxonfile(polyaxonfile,
params=params,
profile=profile,
nocache=nocache,
log=False)
owner, project_name = get_project_or_local(project)
tags = validate_tags(tags)
if local:
try:
run_spec = get_specification(specification.generate_run_data())
run_spec.apply_context()
except PolyaxonSchemaError:
Printer.print_error(
"Could not run this polyaxonfile locally, "
"a context is required to resolve it dependencies.")
sys.exit(1)
if conda_env:
conda_run(
ctx=ctx,
name=name,
owner=owner,
project_name=project_name,
description=description,
tags=tags,
specification=run_spec,
log=log,
conda_env=conda_env,
)
else:
docker_run(
ctx=ctx,
name=name,
owner=owner,
project_name=project_name,
description=description,
tags=tags,
specification=run_spec,
log=log,
)
else:
platform_run(
ctx=ctx,
name=name,
owner=owner,
project_name=project_name,
description=description,
tags=tags,
specification=specification,
upload=upload,
log=log,
can_upload=all([upload, project]),
)