def _handle_run_statuses():
if not conditions:
return
Printer.print_header("Latest status:")
latest_status = Printer.add_status_color({"status": status},
status_key="status")
click.echo("{}\n".format(latest_status["status"]))
objects = list_dicts_to_tabulate([
Printer.add_status_color(o.to_dict(), status_key="type")
for o in conditions
])
if objects:
Printer.print_header("Conditions:")
dict_tabulate(objects, is_list_dict=True)
def get_run_details(run): # pylint:disable=redefined-outer-name
if run.description:
Printer.print_header("Run description:")
click.echo("{}\n".format(run.description))
if run.inputs:
Printer.print_header("Run inputs:")
dict_tabulate(run.inputs)
if run.outputs:
Printer.print_header("Run outputs:")
dict_tabulate(run.outputs)
response = Printer.add_status_color(run.to_dict())
response = dict_to_tabulate(
response,
humanize_values=True,
exclude_attrs=[
"project",
"description",
"readme",
"content",
"raw_content",
"inputs",
"outputs",
"is_managed",
],
)
Printer.print_header("Run info:")
dict_tabulate(response)
def handle_status(last_status: str = None):
if not last_status:
return {"status": None}
click.echo("{}".format(
Printer.add_status_color({"status": last_status},
status_key="status")["status"]))
return last_status
def _get_run_statuses():
try:
for status, conditions in get_run_statuses(owner, project_name,
run_uuid, watch):
if not conditions:
continue
Printer.print_header("Latest status:")
latest_status = Printer.add_status_color({"status": status},
status_key="status")
click.echo("{}\n".format(latest_status["status"]))
objects = list_dicts_to_tabulate([
Printer.add_status_color(o.to_dict(), status_key="type")
for o in conditions
])
if objects:
Printer.print_header("Conditions:")
dict_tabulate(objects, is_list_dict=True)
except (ApiException, HTTPError, PolyaxonClientException) as e:
handle_cli_error(
e, message="Could get status for run `{}`.".format(run_uuid))
sys.exit(1)
def runs(ctx, limit, offset):
"""List bookmarked runs for user.
Uses [Caching](/references/polyaxon-cli/#caching)
Examples:
\b
```bash
$ polyaxon bookmark experiments
```
\b
```bash
$ polyaxon bookmark -u adam experiments
```
"""
user = get_username_or_local(ctx.obj.get("username"))
try:
params = get_query_params(limit=limit, offset=offset)
polyaxon_client = PolyaxonClient()
response = polyaxon_client.runs_v1.list_bookmarked_runs(user, **params)
except (ApiException, HTTPError) as e:
handle_cli_error(
e,
message="Could not get bookmarked experiments for user `{}`.".format(user),
)
sys.exit(1)
meta = get_meta_response(response)
if meta:
Printer.print_header("Bookmarked experiments for user `{}`.".format(user))
Printer.print_header("Navigation:")
dict_tabulate(meta)
else:
Printer.print_header(
"No bookmarked experiments found for user `{}`.".format(user)
)
objects = [
Printer.add_status_color(o.to_light_dict(humanize_values=True))
for o in response.results
]
objects = list_dicts_to_tabulate(objects)
if objects:
Printer.print_header("Experiments:")
dict_tabulate(objects, is_list_dict=True)
def service(ctx, yes, external, url):
"""Open the operation service in browser.
N.B. The operation must have a run kind service, otherwise it will raise an error.
You can open the service embedded in Polyaxon UI or using the real service URL,
please use the `--external` flag.
"""
owner, project_name, run_uuid = get_project_run_or_local(
ctx.obj.get("project"), ctx.obj.get("run_uuid"), is_cli=True,
)
client = RunClient(owner=owner, project=project_name, run_uuid=run_uuid)
client.refresh_data()
if client.run_data.kind != V1RunKind.SERVICE:
Printer.print_warning(
"Command expected an operation of "
"kind `service` received kind: `{}`!".format(client.run_data.kind)
)
sys.exit(1)
Printer.print_header("Waiting for running condition ...")
client.wait_for_condition(
statuses={V1Statuses.RUNNING} | LifeCycle.DONE_VALUES, print_status=True
)
client.refresh_data()
if LifeCycle.is_done(client.run_data.status):
Printer.print_header("The operations reached a done statuses.")
latest_status = Printer.add_status_color(
{"status": client.run_data.status}, status_key="status"
)
click.echo("{}\n".format(latest_status["status"]))
run_url = get_dashboard_url(
subpath="{}/{}/runs/{}/service".format(owner, project_name, run_uuid)
)
namespace = client.run_data.settings.namespace
service_endpoint = SERVICES_V1
if client.run_data.meta_info.get("rewrite_path", False):
service_endpoint = REWRITE_SERVICES_V1
external_run_url = get_dashboard_url(
base=service_endpoint,
subpath="{}/{}/{}/runs/{}/".format(namespace, owner, project_name, run_uuid),
)
if url:
Printer.print_header("The service will be available at: {}".format(run_url))
Printer.print_header(
"You can also view it in an external link at: {}".format(external_run_url)
)
sys.exit(0)
if not yes:
click.confirm(
"Dashboard page will now open in your browser. Continue?",
abort=True,
default=True,
)
if external:
click.launch(external_run_url)
sys.exit(0)
click.launch(run_url)
def ls(ctx, io, query, sort, limit, offset, columns):
"""List runs for this project.
Uses /docs/core/cli/#caching
Examples:
Get all runs:
\b
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
$ polyaxon ops ls \
-q "status:created|running, started_at:2018-01-01..2018-01-02, \
params.activation:sigmoid, metrics.loss:<=0.2"
Get all runs sorted by update date:
\b
$ polyaxon ops ls -s "-updated_at"
Get all runs of kind job:
\b
$ polyaxon ops ls -q "kind: job"
Get all runs of kind service:
\b
$ polyaxon ops ls -q "kind: service"
"""
owner, project_name = get_project_or_local(ctx.obj.get("project"), is_cli=True)
try:
polyaxon_client = RunClient(owner=owner, project=project_name)
response = polyaxon_client.list(
limit=limit, offset=offset, query=query, sort=sort
)
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("Runs 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,
include_attrs=validate_tags(columns),
exclude_attrs=[
"owner",
"project",
"description",
"content",
"raw_content",
"deleted",
"readme",
"settings",
"meta_info",
"original",
"pipeline",
"role",
"status_conditions",
"is_helper",
],
)
else:
objects = list_dicts_to_tabulate(
objects,
include_attrs=validate_tags(columns),
exclude_attrs=[
"owner",
"project",
"description",
"content",
"raw_content",
"deleted",
"readme",
"inputs",
"outputs",
"settings",
"meta_info",
"original",
"pipeline",
"role",
"status_conditions",
"is_helper",
],
)
if objects:
Printer.print_header("Runs:")
objects.pop("project_name", None)
dict_tabulate(objects, is_list_dict=True)
def ls(ctx, project, io, to_csv, query, sort, limit, offset, columns, offline,
offline_path):
"""List runs for this project.
Uses /docs/core/cli/#caching
Examples:
Get all runs:
\b
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
$ polyaxon ops ls \
-q "status:created|running, started_at:2018-01-01..2018-01-02, \
params.activation:sigmoid, metrics.loss:<=0.2"
Get all runs sorted by update date:
\b
$ polyaxon ops ls -s "-updated_at"
Get all runs of kind job:
\b
$ polyaxon ops ls -q "kind: job"
Get all runs of kind service:
\b
$ polyaxon ops ls -q "kind: service"
"""
if offline:
offline_path = offline_path or container_contexts.CONTEXT_OFFLINE_ROOT
offline_path_format = "{}/{{}}/run_data.json".format(offline_path)
if not os.path.exists(offline_path) or not os.path.isdir(offline_path):
Printer.print_error(
f"Could not list offline runs, the path `{offline_path}` "
f"does not exist or is not a directory.")
sys.exit(1)
results = []
for uid in os.listdir(offline_path):
run_path = offline_path_format.format(uid)
if os.path.exists(run_path):
results.append(RunConfigManager.read_from_path(run_path))
else:
Printer.print_warning(
f"Skipping run {uid}, offline data not found.")
else:
owner, project_name = get_project_or_local(project
or ctx.obj.get("project"),
is_cli=True)
try:
polyaxon_client = RunClient(owner=owner, project=project_name)
response = polyaxon_client.list(limit=limit,
offset=offset,
query=query,
sort=sort)
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("Runs 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))
results = response.results
objects = [Printer.add_status_color(o.to_dict()) for o in results]
columns = validate_tags(columns)
if io:
objects, prefixed_columns = flatten_keys(
objects=objects,
columns=["inputs", "outputs"],
columns_prefix={
"inputs": "in",
"outputs": "out"
},
)
if columns:
columns = {prefixed_columns.get(col, col) for col in columns}
if to_csv:
objects = list_dicts_to_csv(
objects,
include_attrs=columns,
exclude_attrs=DEFAULT_EXCLUDE,
)
else:
objects = list_dicts_to_tabulate(
objects,
include_attrs=columns,
exclude_attrs=DEFAULT_EXCLUDE,
humanize_values=True,
upper_keys=True,
)
else:
if to_csv:
objects = list_dicts_to_csv(
objects,
include_attrs=columns,
exclude_attrs=DEFAULT_EXCLUDE + ["inputs", "outputs"],
)
else:
objects = list_dicts_to_tabulate(
objects,
include_attrs=columns,
exclude_attrs=DEFAULT_EXCLUDE + ["inputs", "outputs"],
humanize_values=True,
upper_keys=True,
)
if objects:
if to_csv:
filename = "./results.csv"
write_csv(objects, filename=filename)
Printer.print_success("CSV file generated: `{}`".format(filename))
else:
Printer.print_header("Runs:")
objects.pop("project_name", None)
dict_tabulate(objects, is_list_dict=True)
def ls(ctx, io, to_csv, query, sort, limit, offset, columns):
"""List runs for this project.
Uses /docs/core/cli/#caching
Examples:
Get all runs:
\b
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
$ polyaxon ops ls \
-q "status:created|running, started_at:2018-01-01..2018-01-02, \
params.activation:sigmoid, metrics.loss:<=0.2"
Get all runs sorted by update date:
\b
$ polyaxon ops ls -s "-updated_at"
Get all runs of kind job:
\b
$ polyaxon ops ls -q "kind: job"
Get all runs of kind service:
\b
$ polyaxon ops ls -q "kind: service"
"""
owner, project_name = get_project_or_local(ctx.obj.get("project"),
is_cli=True)
try:
polyaxon_client = RunClient(owner=owner, project=project_name)
response = polyaxon_client.list(limit=limit,
offset=offset,
query=query,
sort=sort)
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("Runs 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]
columns = validate_tags(columns)
if io:
objects, prefixed_columns = flatten_keys(
objects=objects,
columns=["inputs", "outputs"],
columns_prefix={
"inputs": "in",
"outputs": "out"
},
)
if columns:
columns = {prefixed_columns.get(col, col) for col in columns}
if to_csv:
objects = list_dicts_to_csv(
objects,
include_attrs=columns,
exclude_attrs=DEFAULT_EXCLUDE,
)
else:
objects = list_dicts_to_tabulate(
objects,
include_attrs=columns,
exclude_attrs=DEFAULT_EXCLUDE,
humanize_values=True,
upper_keys=True,
)
else:
if to_csv:
objects = list_dicts_to_csv(
objects,
include_attrs=columns,
exclude_attrs=DEFAULT_EXCLUDE,
)
else:
objects = list_dicts_to_tabulate(
objects,
include_attrs=columns,
exclude_attrs=DEFAULT_EXCLUDE,
humanize_values=True,
upper_keys=True,
)
if objects:
if to_csv:
write_csv(objects)
else:
Printer.print_header("Runs:")
objects.pop("project_name", None)
dict_tabulate(objects, is_list_dict=True)
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)
