def get_experiment_details(experiment): # pylint:disable=redefined-outer-name
if experiment.description:
Printer.print_header("Experiment description:")
click.echo('{}\n'.format(experiment.description))
if experiment.resources:
get_resources(experiment.resources.to_dict(),
header="Experiment resources:")
if experiment.params:
Printer.print_header("Experiment params:")
dict_tabulate(experiment.params)
if experiment.last_metric:
Printer.print_header("Experiment last metrics:")
dict_tabulate(experiment.last_metric)
response = experiment.to_light_dict(humanize_values=True,
exclude_attrs=[
'uuid', 'config', 'project',
'experiments', 'description',
'params', 'last_metric',
'resources', 'jobs', 'run_env'
])
Printer.print_header("Experiment info:")
dict_tabulate(Printer.add_status_color(response))
def get_experiment_job_statuses():
try:
response = PolyaxonClient().experiment_job.get_statuses(
user, project_name, _experiment, _job, page=page)
except (PolyaxonHTTPError, PolyaxonShouldExitError,
PolyaxonClientException) as e:
Printer.print_error(
'Could not get status for job `{}`.'.format(job))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
meta = get_meta_response(response)
if meta:
Printer.print_header('Statuses for Job `{}`.'.format(_job))
Printer.print_header('Navigation:')
dict_tabulate(meta)
else:
Printer.print_header(
'No statuses found for job `{}`.'.format(_job))
objects = list_dicts_to_tabulate([
Printer.add_status_color(o.to_light_dict(humanize_values=True),
status_key='status')
for o in response['results']
])
if objects:
Printer.print_header("Statuses:")
objects.pop('job', None)
dict_tabulate(objects, is_list_dict=True)
def experiments(ctx, page, metrics):
"""List experiments for this experiment group
Uses [Caching](/polyaxon_cli/introduction#Caching)
"""
user, project_name, _group = get_group_or_local(ctx.obj['project'], ctx.obj['group'])
page = page or 1
try:
response = PolyaxonClients().experiment_group.list_experiments(
user, project_name, _group, page=page)
except (PolyaxonHTTPError, PolyaxonShouldExitError) as e:
Printer.print_error('Could not get experiments for group `{}`.'.format(_group))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
meta = get_meta_response(response)
if meta:
Printer.print_header('Experiments for experiment group `{}`.'.format(_group))
Printer.print_header('Navigation:')
dict_tabulate(meta)
else:
Printer.print_header('No experiments found for experiment group `{}`.'.format(_group))
if metrics:
objects = get_experiments_with_metrics(response)
else:
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:")
objects.pop('experiment_group', None)
objects.pop('experiment_group_name', None)
objects.pop('project_name', None)
dict_tabulate(objects, is_list_dict=True)
def tensorboards(ctx, query, sort, page):
"""List tensorboard jobs for this project.
Uses [Caching](/references/polyaxon-cli/#caching)
"""
user, project_name = get_project_or_local(ctx.obj.get('project'))
page = page or 1
try:
response = PolyaxonClient().project.list_tensorboards(username=user,
project_name=project_name,
query=query,
sort=sort,
page=page)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not get tensorboards for project `{}`.'.format(project_name))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
meta = get_meta_response(response)
if meta:
Printer.print_header('Tensorboards for project `{}/{}`.'.format(user, project_name))
Printer.print_header('Navigation:')
dict_tabulate(meta)
else:
Printer.print_header('No tensorboards found for project `{}/{}`.'.format(user,
project_name))
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("Tensorboards:")
objects.pop('project_name', None)
dict_tabulate(objects, is_list_dict=True)
def get_group_details(group): # pylint:disable=redefined-outer-name
if group.description:
Printer.print_header("Experiment group description:")
click.echo('{}\n'.format(group.description))
response = group.to_light_dict(humanize_values=True,
exclude_attrs=[
'uuid', 'content', 'project',
'experiments', 'description'
])
Printer.print_header("Experiment group info:")
dict_tabulate(Printer.add_status_color(response))
def experiments(ctx, metrics, declarations, query, sort, page):
"""List experiments for this experiment group
Uses [Caching](/references/polyaxon-cli/#caching)
"""
user, project_name, _group = get_project_group_or_local(
ctx.obj.get('project'), ctx.obj.get('group'))
page = page or 1
try:
response = PolyaxonClient().experiment_group.list_experiments(
username=user,
project_name=project_name,
group_id=_group,
metrics=metrics,
declarations=declarations,
query=query,
sort=sort,
page=page)
except (PolyaxonHTTPError, PolyaxonShouldExitError,
PolyaxonClientException) as e:
Printer.print_error(
'Could not get experiments for group `{}`.'.format(_group))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
meta = get_meta_response(response)
if meta:
Printer.print_header(
'Experiments for experiment group `{}`.'.format(_group))
Printer.print_header('Navigation:')
dict_tabulate(meta)
else:
Printer.print_header(
'No experiments found for experiment group `{}`.'.format(_group))
if metrics:
objects = get_experiments_with_metrics(response)
elif declarations:
objects = get_experiments_with_declarations(response)
else:
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:")
objects.pop('experiment_group', None)
objects.pop('experiment_group_name', None)
objects.pop('project_name', None)
dict_tabulate(objects, is_list_dict=True)
def groups(ctx, page):
"""List bookmarked experiment groups for user.
Uses [Caching](/references/polyaxon-cli/#caching)
Examples:
\b
```bash
$ polyaxon bookmark groups
```
\b
```bash
$ polyaxon bookmark -u adam groups
```
"""
user = get_username_or_local(ctx.obj.get('username'))
page = page or 1
try:
response = PolyaxonClient().bookmark.groups(username=user, page=page)
except (PolyaxonHTTPError, PolyaxonShouldExitError,
PolyaxonClientException) as e:
Printer.print_error(
'Could not get bookmarked experiment groups for user `{}`.'.format(
user))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
meta = get_meta_response(response)
if meta:
Printer.print_header(
'Bookmarked experiment groups for user `{}`.'.format(user))
Printer.print_header('Navigation:')
dict_tabulate(meta)
else:
Printer.print_header(
'No bookmarked experiment groups 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("Experiment groups:")
dict_tabulate(objects, is_list_dict=True)
def get_build_details(_build):
if _build.description:
Printer.print_header("Build description:")
click.echo('{}\n'.format(_build.description))
if _build.resources:
get_resources(_build.resources.to_dict(), header="Build resources:")
response = _build.to_light_dict(
humanize_values=True,
exclude_attrs=[
'uuid', 'content', 'project', 'description', 'resources', 'is_clone', 'build_job'
])
Printer.print_header("Build info:")
dict_tabulate(Printer.add_status_color(response))
def statuses(ctx, page):
"""Get build job statuses.
Uses [Caching](/polyaxon_cli/introduction#Caching)
Examples:
\b
```bash
$ polyaxon build -b 2 statuses
```
"""
user, project_name, _build = get_build_or_local(ctx.obj.get('project'),
ctx.obj.get('build'))
page = page or 1
try:
response = PolyaxonClient().build_job.get_statuses(user,
project_name,
_build,
page=page)
except (PolyaxonHTTPError, PolyaxonShouldExitError,
PolyaxonClientException) as e:
Printer.print_error(
'Could not get status for build job `{}`.'.format(_build))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
meta = get_meta_response(response)
if meta:
Printer.print_header('Statuses for build job `{}`.'.format(_build))
Printer.print_header('Navigation:')
dict_tabulate(meta)
else:
Printer.print_header(
'No statuses found for build job `{}`.'.format(_build))
objects = list_dicts_to_tabulate([
Printer.add_status_color(o.to_light_dict(humanize_values=True),
status_key='status')
for o in response['results']
])
if objects:
Printer.print_header("Statuses:")
objects.pop('job', None)
dict_tabulate(objects, is_list_dict=True)
def jobs(ctx, page):
"""List jobs for experiment.
Uses [Caching](/references/polyaxon-cli/#caching)
Examples:
\b
```bash
$ polyaxon experiment --experiment=1 jobs
```
"""
user, project_name, _experiment = get_project_experiment_or_local(
ctx.obj.get('project'), ctx.obj.get('experiment'))
page = page or 1
try:
response = PolyaxonClient().experiment.list_jobs(user,
project_name,
_experiment,
page=page)
except (PolyaxonHTTPError, PolyaxonShouldExitError,
PolyaxonClientException) as e:
Printer.print_error(
'Could not get jobs for experiment `{}`.'.format(_experiment))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
meta = get_meta_response(response)
if meta:
Printer.print_header('Jobs for experiment `{}`.'.format(_experiment))
Printer.print_header('Navigation:')
dict_tabulate(meta)
else:
Printer.print_header(
'No jobs found for experiment `{}`.'.format(_experiment))
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("Jobs:")
objects.pop('experiment', None)
dict_tabulate(objects, is_list_dict=True)
def statuses(ctx, page):
"""Get experiment group statuses.
Uses [Caching](/references/polyaxon-cli/#caching)
Examples:
\b
```bash
$ polyaxon group -g 2 statuses
```
"""
user, project_name, _group = get_project_group_or_local(
ctx.obj.get('project'), ctx.obj.get('group'))
page = page or 1
try:
response = PolyaxonClient().experiment_group.get_statuses(user,
project_name,
_group,
page=page)
except (PolyaxonHTTPError, PolyaxonShouldExitError,
PolyaxonClientException) as e:
Printer.print_error(
'Could not get status for group `{}`.'.format(_group))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
meta = get_meta_response(response)
if meta:
Printer.print_header('Statuses for group `{}`.'.format(_group))
Printer.print_header('Navigation:')
dict_tabulate(meta)
else:
Printer.print_header(
'No statuses found for group `{}`.'.format(_group))
objects = list_dicts_to_tabulate([
Printer.add_status_color(o.to_light_dict(humanize_values=True),
status_key='status')
for o in response['results']
])
if objects:
Printer.print_header("Statuses:")
objects.pop('experiment_group', None)
dict_tabulate(objects, is_list_dict=True)
def get_job_details(_job):
if _job.description:
Printer.print_header("Job description:")
click.echo('{}\n'.format(_job.description))
if _job.resources:
get_resources(_job.resources.to_dict(), header="Job resources:")
response = _job.to_light_dict(humanize_values=True,
exclude_attrs=[
'uuid',
'content',
'project',
'description',
'resources',
])
Printer.print_header("Job info:")
dict_tabulate(Printer.add_status_color(response))
def get(ctx):
"""Get job.
Uses [Caching](/polyaxon_cli/introduction#Caching)
Examples:
\b
```bash
$ polyaxon job --job=1 --experiment=1 get
```
\b
```bash
$ polyaxon job --job=1 --project=project_name get
```
"""
user, project_name, experiment, _job = get_job_or_local(
ctx.obj['project'], ctx.obj['experiment'], ctx.obj['job'])
try:
response = PolyaxonClients().job.get_job(user, project_name,
experiment, _job)
# Set caching only if we have an initialized project
if ProjectManager.is_initialized():
JobManager.set_config(response)
except (PolyaxonHTTPError, PolyaxonShouldExitError) as e:
Printer.print_error('Could not get job `{}`.'.format(_job))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
if response.resources:
get_resources(response.resources.to_dict(), header="Job resources:")
response = Printer.add_status_color(
response.to_light_dict(humanize_values=True,
exclude_attrs=[
'uuid', 'definition', 'experiment',
'unique_name', 'resources'
]))
Printer.print_header("Job info:")
dict_tabulate(response)
def get_experiment_job():
try:
response = PolyaxonClient().experiment_job.get_job(user,
project_name,
_experiment,
_job)
cache.cache(config_manager=ExperimentJobManager, response=response)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not get job `{}`.'.format(_job))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
if response.resources:
get_resources(response.resources.to_dict(), header="Job resources:")
response = Printer.add_status_color(response.to_light_dict(
humanize_values=True,
exclude_attrs=['uuid', 'definition', 'experiment', 'unique_name', 'resources']
))
Printer.print_header("Job info:")
dict_tabulate(response)
def builds(ctx, query, sort, page):
"""List build jobs for this project.
Uses [Caching](/references/polyaxon-cli/#caching)
Examples:
Get all builds:
\b
```bash
$ polyaxon project builds
```
Get all builds with with status not in {created or running}
\b
```bash
$ polyaxon project builds -q "status:~created"
```
Get all builds with with status failed
\b
```bash
$ polyaxon project builds -q "status:failed"
```
Get all builds sorted by update date
\b
```bash
$ polyaxon project builds -s "-updated_at"
```
"""
user, project_name = get_project_or_local(ctx.obj.get('project'))
page = page or 1
try:
response = PolyaxonClient().project.list_builds(
username=user,
project_name=project_name,
query=query,
sort=sort,
page=page)
except (PolyaxonHTTPError, PolyaxonShouldExitError,
PolyaxonClientException) as e:
Printer.print_error(
'Could not get builds for project `{}`.'.format(project_name))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
meta = get_meta_response(response)
if meta:
Printer.print_header('Builds for project `{}/{}`.'.format(
user, project_name))
Printer.print_header('Navigation:')
dict_tabulate(meta)
else:
Printer.print_header('No builds found for project `{}/{}`.'.format(
user, project_name))
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("Builds:")
objects.pop('project_name', None)
dict_tabulate(objects, is_list_dict=True)
def experiments(ctx, metrics, declarations, independent, group, query, sort,
page):
"""List experiments for this project.
Uses [Caching](/references/polyaxon-cli/#caching)
Examples:
Get all experiments:
\b
```bash
$ polyaxon project experiments
```
Get all experiments with with status {created or running}, and
creation date between 2018-01-01 and 2018-01-02, and declarations activation equal to sigmoid
and metric loss less or equal to 0.2
\b
```bash
$ polyaxon project experiments \
-q "status:created|running, started_at:2018-01-01..2018-01-02, \
declarations.activation:sigmoid, metric.loss:<=0.2"
```
Get all experiments sorted by update date
\b
```bash
$ polyaxon project experiments -s "-updated_at"
```
"""
user, project_name = get_project_or_local(ctx.obj.get('project'))
page = page or 1
try:
response = PolyaxonClient().project.list_experiments(
username=user,
project_name=project_name,
independent=independent,
group=group,
metrics=metrics,
declarations=declarations,
query=query,
sort=sort,
page=page)
except (PolyaxonHTTPError, PolyaxonShouldExitError,
PolyaxonClientException) as e:
Printer.print_error(
'Could not get experiments for project `{}`.'.format(project_name))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
meta = get_meta_response(response)
if meta:
Printer.print_header('Experiments for project `{}/{}`.'.format(
user, project_name))
Printer.print_header('Navigation:')
dict_tabulate(meta)
else:
Printer.print_header(
'No experiments found for project `{}/{}`.'.format(
user, project_name))
if metrics:
objects = get_experiments_with_metrics(response)
elif declarations:
objects = get_experiments_with_declarations(response)
else:
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:")
objects.pop('project_name', None)
dict_tabulate(objects, is_list_dict=True)
def groups(ctx, query, sort, page):
"""List experiment groups for this project.
Uses [Caching](/references/polyaxon-cli/#caching)
Examples:
Get all groups:
\b
```bash
$ polyaxon project groups
```
Get all groups with with status {created or running}, and
creation date between 2018-01-01 and 2018-01-02,
and search algorithm not in {grid or random search}
\b
```bash
$ polyaxon project groups \
-q "status:created|running, started_at:2018-01-01..2018-01-02, search_algorithm:~grid|random"
```
Get all groups sorted by update date
\b
```bash
$ polyaxon project groups -s "-updated_at"
```
"""
user, project_name = get_project_or_local(ctx.obj.get('project'))
page = page or 1
try:
response = PolyaxonClient().project.list_experiment_groups(
username=user,
project_name=project_name,
query=query,
sort=sort,
page=page)
except (PolyaxonHTTPError, PolyaxonShouldExitError,
PolyaxonClientException) as e:
Printer.print_error(
'Could not get experiment groups for project `{}`.'.format(
project_name))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
meta = get_meta_response(response)
if meta:
Printer.print_header('Experiment groups for project `{}/{}`.'.format(
user, project_name))
Printer.print_header('Navigation:')
dict_tabulate(meta)
else:
Printer.print_header(
'No experiment groups found for project `{}/{}`.'.format(
user, project_name))
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("Experiment groups:")
objects.pop('project', None)
objects.pop('user', None)
dict_tabulate(objects, is_list_dict=True)
