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 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 get(experiment, project):
"""Get experiment by uuid.
Examples:
```
polyaxon experiment get 1
```
```
polyaxon experiment get 1 --project=cats-vs-dogs
```
```
polyaxon experiment get 1 --project=alain/cats-vs-dogs
```
"""
user, project_name = get_project_or_local(project)
try:
response = PolyaxonClients().experiment.get_experiment(
user, project_name, experiment)
except (PolyaxonHTTPError, PolyaxonShouldExitError) as e:
Printer.print_error(
'Could not load experiment `{}` info.'.format(experiment))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
response = response.to_dict()
Printer.print_header("Experiment info:")
dict_tabulate(response)
def update(group, project, description):
"""Update experiement group.
Example:
```
polyaxon group update 2 --description="new description for my experiments"
```
"""
user, project_name = get_project_or_local(project)
update_dict = {}
if description:
update_dict['description'] = description
if not update_dict:
Printer.print_warning(
'No argument was provided to update the experiment group.')
sys.exit(0)
try:
response = PolyaxonClients().experiment_group.update_experiment_group(
user, project_name, group, update_dict)
except (PolyaxonHTTPError, PolyaxonShouldExitError) as e:
Printer.print_error(
'Could not update experiment group `{}`.'.format(group))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
Printer.print_success("Experiment group updated.")
response = response.to_dict()
Printer.print_header("Experiment group info:")
dict_tabulate(response)
def get(project):
"""Get info for current project, by project_name, or user/project_name.
Examples:
To get current project:
```
polyaxon project get
```
To get a project by uuid
```
polyaxon project get user/project
```
"""
user, project_name = get_project_or_local(project)
try:
response = PolyaxonClients().project.get_project(user, project_name)
except (PolyaxonHTTPError, PolyaxonShouldExitError) as e:
Printer.print_error('Could not get project `{}`.'.format(project))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
response = response.to_dict()
Printer.print_header("Project info:")
dict_tabulate(response)
def list(page):
"""List projects."""
user = AuthConfigManager.get_value('username')
if not user:
Printer.print_error('Please login first. `polyaxon login --help`')
page = page or 1
try:
response = PolyaxonClients().project.list_projects(user, page=page)
except (PolyaxonHTTPError, PolyaxonShouldExitError) as e:
Printer.print_error('Could not get list of projects.')
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
meta = get_meta_response(response)
if meta:
Printer.print_header('Projects for current user')
Printer.print_header('Navigation:')
dict_tabulate(meta)
else:
Printer.print_header('No projects found for current user')
objects = list_dicts_to_tabulate(
[o.to_dict() for o in response['results']])
if objects:
Printer.print_header("Projects:")
dict_tabulate(objects, is_list_dict=True)
def list(page): # pylint:disable=redefined-builtin
"""List projects.
Uses [Caching](/references/polyaxon-cli/#caching)
"""
user = AuthConfigManager.get_value('username')
if not user:
Printer.print_error('Please login first. `polyaxon login --help`')
page = page or 1
try:
response = PolyaxonClient().project.list_projects(user, page=page)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not get list of projects.')
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
meta = get_meta_response(response)
if meta:
Printer.print_header('Projects for current user')
Printer.print_header('Navigation:')
dict_tabulate(meta)
else:
Printer.print_header('No projects found for current user')
objects = list_dicts_to_tabulate(
[o.to_light_dict(
humanize_values=True,
exclude_attrs=['uuid', 'experiment_groups', 'experiments', 'description',
'num_experiments', 'num_independent_experiments',
'num_experiment_groups', 'num_jobs', 'num_builds', 'unique_name'])
for o in response['results']])
if objects:
Printer.print_header("Projects:")
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 statuses(experiment, job, project):
"""Get job status.
Examples:
```
polyaxon job status 50c62372137940ca8c456d8596946dd7
```
"""
user, project_name = get_project_or_local(project)
try:
response = PolyaxonClients().job.get_statuses(user, project_name,
experiment, job)
except (PolyaxonHTTPError, PolyaxonShouldExitError) 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(
[o.to_dict() for o in response['results']])
if objects:
Printer.print_header("Statuses:")
objects.pop('job')
dict_tabulate(objects, is_list_dict=True)
def version(cli, platform):
"""Print the current version of the cli and platform."""
version_client = PolyaxonClient().version
cli = cli or not any([cli, platform])
if cli:
try:
server_version = version_client.get_cli_version()
except AuthorizationError:
session_expired()
sys.exit(1)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not get cli version.')
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
cli_version = get_current_version()
Printer.print_header('Current cli version: {}.'.format(cli_version))
Printer.print_header('Supported cli versions:')
dict_tabulate(server_version.to_dict())
if platform:
try:
platform_version = version_client.get_platform_version()
except AuthorizationError:
session_expired()
sys.exit(1)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not get platform version.')
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
chart_version = version_client.get_chart_version()
Printer.print_header('Current platform version: {}.'.format(chart_version.version))
Printer.print_header('Supported platform versions:')
dict_tabulate(platform_version.to_dict())
def experiments(group, project, page):
"""List experiments for this experiment group"""
user, project_name = get_project_or_local(project)
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))
objects = list_dicts_to_tabulate(
[o.to_dict() for o in response['results']])
if objects:
Printer.print_header("Experiments:")
objects.pop('group')
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(response)
def get_project_details(_project):
if _project.description:
Printer.print_header("Project description:")
click.echo('{}\n'.format(_project.description))
response = _project.to_light_dict(
humanize_values=True,
exclude_attrs=['uuid', 'experiment_groups', 'experiments', 'description'])
Printer.print_header("Project info:")
dict_tabulate(response)
def get_group_experiments_info(search_algorithm, concurrency, early_stopping=False, **kwargs):
info = OrderedDict()
info['Search algorithm'] = search_algorithm.lower()
info['Concurrency'] = ('{} runs'.format('sequential')
if concurrency == 1 else
'{} concurrent runs'.format(concurrency))
info['Early stopping'] = 'activated' if early_stopping else 'deactivated'
if 'n_experiments' in kwargs:
info['Experiments to create'] = kwargs['n_experiments']
dict_tabulate(info)
def get_cluster_info(cluster_config):
Printer.print_header("Cluster info:")
cluster_dict = cluster_config.to_dict()
cluster_info = cluster_dict['version_api']
dict_tabulate(cluster_info)
nodes = list_dicts_to_tabulate(cluster_dict['nodes'])
if nodes:
Printer.print_header("Cluster Nodes:")
dict_tabulate(nodes, is_list_dict=True)
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 get_cluster_info(cluster_config):
Printer.print_header("Cluster info:")
cluster_dict = cluster_config.to_light_dict()
cluster_info = cluster_dict['version_api']
dict_tabulate(cluster_info)
nodes = list_dicts_to_tabulate([Printer.add_memory_unit(node.to_light_dict(), 'memory')
for node in cluster_config.nodes])
if nodes:
Printer.print_header("Cluster Nodes:")
nodes.pop('status', None)
nodes.pop('kernel_version', None)
dict_tabulate(nodes, 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_node_info(node_config):
if not node_config:
Printer.print_error('No node was found.')
sys.exit(1)
node = node_config.to_dict()
node.pop('gpus')
Printer.print_header("Node info:")
dict_tabulate(Printer.add_memory_unit(node, 'memory'))
gpus_items = list_dicts_to_tabulate([Printer.add_memory_unit(gpu.to_light_dict(), 'memory')
for gpu in node_config.gpus])
if gpus_items:
Printer.print_header("Node GPUs:")
dict_tabulate(gpus_items, is_list_dict=True)
def get_node_info(node_config):
if not node_config:
Printer.print_error('No node was found.')
sys.exit(1)
node = node_config.to_dict()
gpus = node.pop('gpus', [])
Printer.print_header("Node info:")
dict_tabulate(node)
gpus_items = list_dicts_to_tabulate(gpus)
if gpus_items:
Printer.print_header("Node GPUs:")
gpus_items.pop('cluster_node')
dict_tabulate(gpus_items, is_list_dict=True)
def restart(experiment, project):
"""Delete experiment group."""
user, project_name = get_project_or_local(project)
try:
response = PolyaxonClients().experiment.restart(
user, project_name, experiment)
except (PolyaxonHTTPError, PolyaxonShouldExitError) as e:
Printer.print_error(
'Could not restart experiment `{}`.'.format(experiment))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
response = response.to_dict()
Printer.print_header("Experiment info:")
dict_tabulate(response)
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 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 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 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 run(file, description):
"""Command for running polyaxonfile specification.
Example:
```
polyaxon run -f file -f file_override ...
```
"""
file = file or 'polyaxonfile.yml'
plx_file = check_polyaxonfile(file)
num_experiments, concurrency = plx_file.experiments_def
project = get_current_project_or_exit()
project_client = PolyaxonClients().project
if num_experiments == 1:
click.echo('Creating an independent experiment.')
experiment = ExperimentConfig(
description=description,
content=plx_file._data,
config=plx_file.experiment_specs[0].parsed_data)
try:
response = project_client.create_experiment(
project.user, project.name, experiment)
except (PolyaxonHTTPError, PolyaxonShouldExitError) as e:
Printer.print_error('Could not create experiment.')
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
Printer.print_success('Experiment was created')
else:
click.echo('Creating an experiment group with {} experiments.'.format(
num_experiments))
experiment_group = ExperimentGroupConfig(description=description,
content=plx_file._data)
try:
response = project_client.create_experiment_group(
project.user, project.name, experiment_group)
Printer.print_success('Experiment group was created')
except (PolyaxonHTTPError, PolyaxonShouldExitError) as e:
Printer.print_error('Could not create experiment group.')
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
response = response.to_dict()
dict_tabulate(response)
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 statuses(ctx, page):
"""Get experiment status.
Uses [Caching](/polyaxon_cli/introduction#Caching)
Example:
\b
```bash
$ polyaxon experiment statuses 3
```
\b
```bash
$ polyaxon experiment -xp 1 statuses
```
"""
user, project_name, _experiment = get_experiment_or_local(ctx.obj['project'],
ctx.obj['experiment'])
page = page or 1
try:
response = PolyaxonClients().experiment.get_statuses(
user, project_name, _experiment, page=page)
except (PolyaxonHTTPError, PolyaxonShouldExitError) as e:
Printer.print_error('Could get status for experiment `{}`.'.format(_experiment))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
meta = get_meta_response(response)
if meta:
Printer.print_header('Statuses for experiment `{}`.'.format(_experiment))
Printer.print_header('Navigation:')
dict_tabulate(meta)
else:
Printer.print_header('No statuses found for experiment `{}`.'.format(_experiment))
objects = list_dicts_to_tabulate([Printer.handle_statuses(o.to_light_dict(humanize_values=True))
for o in response['results']])
if objects:
Printer.print_header("Statuses:")
objects.pop('experiment', None)
dict_tabulate(objects, is_list_dict=True)
def get(experiment, job, project):
"""Get job by uuid.
Examples:
```
polyaxon job get 50c62372137940ca8c456d8596946dd7
```
"""
user, project_name = get_project_or_local(project)
try:
response = PolyaxonClients().job.get_job(user, project_name,
experiment, job)
except (PolyaxonHTTPError, PolyaxonShouldExitError) as e:
Printer.print_error('Could not get job `{}`.'.format(job))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
response = response.to_dict()
Printer.print_header("Job info:")
dict_tabulate(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)
