def stop(ctx, yes):
"""Stops the tensorboard deployment for project/experiment/experiment group if it exists.
Uses [Caching](/references/polyaxon-cli/#caching)
Examples: stopping project tensorboard
\b
```bash
$ polyaxon tensorboard stop
```
Examples: stopping experiment group tensorboard
\b
```bash
$ polyaxon tensorboard -g 1 stop
```
Examples: stopping experiment tensorboard
\b
```bash
$ polyaxon tensorboard -xp 112 stop
```
"""
user, project_name = get_project_or_local(ctx.obj.get('project'))
group = ctx.obj.get('group')
experiment = ctx.obj.get('experiment')
if experiment:
obj = 'experiment `{}`'.format(experiment)
elif group:
obj = 'group `{}`'.format(group)
else:
obj = 'project `{}/{}`'.format(user, project_name)
if not yes and not click.confirm("Are sure you want to stop tensorboard "
"for {}".format(obj)):
click.echo('Existing without stopping tensorboard.')
sys.exit(1)
if experiment:
try:
PolyaxonClient().experiment.stop_tensorboard(
username=user,
project_name=project_name,
experiment_id=experiment)
Printer.print_success('Tensorboard is being deleted')
except (PolyaxonHTTPError, PolyaxonShouldExitError,
PolyaxonClientException) as e:
Printer.print_error('Could not stop tensorboard {}.'.format(obj))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
elif group:
try:
PolyaxonClient().experiment_group.stop_tensorboard(
username=user, project_name=project_name, group_id=group)
Printer.print_success('Tensorboard is being deleted')
except (PolyaxonHTTPError, PolyaxonShouldExitError,
PolyaxonClientException) as e:
Printer.print_error('Could not stop tensorboard {}.'.format(obj))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
else:
try:
PolyaxonClient().project.stop_tensorboard(
username=user, project_name=project_name)
Printer.print_success('Tensorboard is being deleted')
except (PolyaxonHTTPError, PolyaxonShouldExitError,
PolyaxonClientException) as e:
Printer.print_error('Could not stop tensorboard {}.'.format(obj))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
def url(ctx):
"""Prints the tensorboard url for project/experiment/experiment group.
Uses [Caching](/references/polyaxon-cli/#caching)
Examples for project tensorboards:
\b
```bash
$ polyaxon tensorboard url
```
\b
```bash
$ polyaxon tensorboard -p mnist url
```
Examples for experiment tensorboards:
\b
```bash
$ polyaxon tensorboard -xp 1 url
```
Examples for experiment group tensorboards:
\b
```bash
$ polyaxon tensorboard -g 1 url
```
"""
user, project_name = get_project_or_local(ctx.obj.get('project'))
group = ctx.obj.get('group')
experiment = ctx.obj.get('experiment')
if experiment:
try:
response = PolyaxonClient().experiment.get_experiment(
username=user,
project_name=project_name,
experiment_id=experiment)
obj = 'experiment {}'.format(experiment)
except (PolyaxonHTTPError, PolyaxonShouldExitError,
PolyaxonClientException) as e:
Printer.print_error(
'Could not get experiment `{}`.'.format(experiment))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
elif group:
try:
response = PolyaxonClient().experiment_group.get_experiment_group(
username=user, project_name=project_name, group_id=group)
obj = 'group `{}`.'.format(group)
except (PolyaxonHTTPError, PolyaxonShouldExitError,
PolyaxonClientException) as e:
Printer.print_error('Could not get group `{}`.'.format(group))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
else:
try:
response = PolyaxonClient().project.get_project(
username=user, project_name=project_name)
obj = 'project `{}`.'.format(project_name)
except (PolyaxonHTTPError, PolyaxonShouldExitError,
PolyaxonClientException) as e:
Printer.print_error(
'Could not get project `{}`.'.format(project_name))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
if response.has_tensorboard:
click.echo(
get_tensorboard_url(user=user,
project_name=project_name,
experiment=experiment,
group=group))
else:
Printer.print_warning(
'This `{}` does not have a running tensorboard'.format(obj))
click.echo(
'You can start tensorboard with this command: polyaxon tensorboard start --help'
)
def login(token, username, password):
"""Login to Polyaxon."""
auth_client = PolyaxonClient().auth
if username:
# Use username / password login
if not password:
password = click.prompt('Please enter your password',
type=str,
hide_input=True)
password = password.strip()
if not password:
logger.info(
'You entered an empty string. '
'Please make sure you enter your password correctly.')
sys.exit(1)
credentials = CredentialsConfig(username=username, password=password)
try:
access_code = auth_client.login(credentials=credentials)
except (PolyaxonHTTPError, PolyaxonShouldExitError,
PolyaxonClientException) as e:
Printer.print_error('Could not login.')
Printer.print_error(e)
sys.exit(1)
if not access_code:
Printer.print_error("Failed to login")
return
else:
if not token:
token_url = "{}/app/token".format(auth_client.config.http_host)
click.confirm(
'Authentication token page will now open in your browser. Continue?',
abort=True,
default=True)
click.launch(token_url)
logger.info("Please copy and paste the authentication token.")
token = click.prompt(
'This is an invisible field. Paste token and press ENTER',
type=str,
hide_input=True)
if not token:
logger.info(
"Empty token received. "
"Make sure your shell is handling the token appropriately.")
logger.info(
"See docs for help: http://docs.polyaxon.com/polyaxon_cli/commands/auth"
)
return
access_code = token.strip(" ")
# Set user
try:
AuthConfigManager.purge()
user = PolyaxonClient().auth.get_user(token=access_code)
except (PolyaxonHTTPError, PolyaxonShouldExitError,
PolyaxonClientException) as e:
Printer.print_error('Could not load user info.')
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
access_token = AccessTokenConfig(username=user.username, token=access_code)
AuthConfigManager.set_config(access_token)
Printer.print_success("Login successful")
# Reset current cli
server_version = get_server_version()
current_version = get_current_version()
log_handler = get_log_handler()
CliConfigManager.reset(check_count=0,
current_version=current_version,
min_version=server_version.min_version,
log_handler=log_handler)
def start(ctx, file): # pylint:disable=redefined-builtin
"""Start a tensorboard deployment for project/experiment/experiment group.
Project tensorboard will aggregate all experiments under the project.
Experiment group tensorboard will aggregate all experiments under the group.
Experiment tensorboard will show all metrics for an experiment.
Uses [Caching](/references/polyaxon-cli/#caching)
Example: using the default tensorflow image 1.4.1.
\b
```bash
$ polyaxon tensorboard start
```
Example: with custom image and resources
\b
```bash
$ polyaxon tensorboard start -f file -f file_override ...
```
Example: starting a tensorboard for an experiment group
\b
```bash
$ polyaxon tensorboard -g 1 start -f file
```
Example: starting a tensorboard for an experiment
\b
```bash
$ polyaxon tensorboard -xp 112 start -f file
```
"""
specification = None
job_config = None
if file:
specification = check_polyaxonfile(file, log=False).specification
if specification:
# pylint:disable=protected-access
check_polyaxonfile_kind(specification=specification,
kind=specification._TENSORBOARD)
job_config = specification.parsed_data
user, project_name = get_project_or_local(ctx.obj.get('project'))
group = ctx.obj.get('group')
experiment = ctx.obj.get('experiment')
if experiment:
try:
response = PolyaxonClient().experiment.start_tensorboard(
username=user,
project_name=project_name,
experiment_id=experiment,
job_config=job_config)
obj = 'experiment `{}`'.format(experiment)
except (PolyaxonHTTPError, PolyaxonShouldExitError,
PolyaxonClientException) as e:
Printer.print_error(
'Could not start tensorboard experiment `{}`.'.format(
experiment))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
elif group:
try:
response = PolyaxonClient().experiment_group.start_tensorboard(
username=user,
project_name=project_name,
group_id=group,
job_config=job_config)
obj = 'group `{}`'.format(group)
except (PolyaxonHTTPError, PolyaxonShouldExitError,
PolyaxonClientException) as e:
Printer.print_error(
'Could not start tensorboard group `{}`.'.format(group))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
else:
try:
response = PolyaxonClient().project.start_tensorboard(
username=user,
project_name=project_name,
job_config=job_config)
obj = 'project `{}`'.format(project_name)
except (PolyaxonHTTPError, PolyaxonShouldExitError,
PolyaxonClientException) as e:
Printer.print_error(
'Could not start tensorboard project `{}`.'.format(
project_name))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
if response.status_code == 200:
Printer.print_header(
"A tensorboard for this {} is already running on:".format(obj))
click.echo(
get_tensorboard_url(user=user,
project_name=project_name,
experiment=experiment,
group=group))
sys.exit(0)
if response.status_code != 201:
Printer.print_error(
'Something went wrong, Tensorboard was not created.')
sys.exit(1)
Printer.print_success('Tensorboard is being deployed for {}'.format(obj))
clint.textui.puts(
"It may take some time before you can access tensorboard.\n")
clint.textui.puts("Your tensorboard will be available on:\n")
with clint.textui.indent(4):
clint.textui.puts(
get_tensorboard_url(user, project_name, experiment, group))
def get_notebook_url(user, project_name):
return "{}/notebook/{}/{}/\n".format(PolyaxonClient().api_config.http_host,
user, project_name)
def start(ctx, file, u): # pylint:disable=redefined-builtin
"""Start a notebook deployment for this project.
Uses [Caching](/polyaxon_cli/introduction#Caching)
Example:
\b
```bash
$ polyaxon notebook start -f file -f file_override ...
```
Example: upload before running
\b
```bash
$ polyaxon -p user12/mnist notebook start -f file -u
```
"""
specification = None
job_config = None
if file:
specification = check_polyaxonfile(file, log=False).specification
# Check if we need to upload
if u:
ctx.invoke(upload)
if specification:
# pylint:disable=protected-access
check_polyaxonfile_kind(specification=specification,
kind=specification._NOTEBOOK)
job_config = specification.parsed_data
user, project_name = get_project_or_local(ctx.obj.get('project'))
try:
response = PolyaxonClient().project.start_notebook(
user, project_name, job_config)
except (PolyaxonHTTPError, PolyaxonShouldExitError,
PolyaxonClientException) as e:
Printer.print_error(
'Could not start notebook project `{}`.'.format(project_name))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
if response.status_code == 200:
Printer.print_header(
"A notebook for this project is already running on:")
click.echo(get_notebook_url(user, project_name))
sys.exit(0)
if response.status_code != 201:
Printer.print_error('Something went wrong, Notebook was not created.')
sys.exit(1)
Printer.print_success(
'Notebook is being deployed for project `{}`'.format(project_name))
clint.textui.puts(
"It may take some time before you can access the notebook.\n")
clint.textui.puts("Your notebook will be available on:\n")
with clint.textui.indent(4):
clint.textui.puts(get_notebook_url(user, project_name))
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, params, 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 params 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, \
params.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,
params=params,
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 params:
objects = get_experiments_with_params(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)
def init(project, run, model):
"""Initialize a new polyaxonfile specification."""
user, project_name = get_project_or_local(project)
try:
project_config = PolyaxonClient().project.get_project(
user, project_name)
except (PolyaxonHTTPError, PolyaxonShouldExitError,
PolyaxonClientException) as e:
Printer.print_error(
'Make sure you have a project with this name `{}`'.format(project))
Printer.print_error(
'You can a create new project with this command: '
'polyaxon project create '
'--name={} [--description=...] [--tags=...]'.format(project_name))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
if not any([model, run]) and not all([model, run]):
Printer.print_error("You must specify which init option, "
"possible values: `--model` or `--run`.")
sys.exit(1)
result = False
if model:
result = create_init_file(constants.INIT_FILE_MODEL)
elif run:
result = create_init_file(constants.INIT_FILE_RUN)
if result:
ProjectManager.purge()
ProjectManager.set_config(project_config, init=True)
IgnoreManager.init_config()
Printer.print_success(
"Project `{}` was initialized and Polyaxonfile was created successfully `{}`"
.format(project, constants.INIT_FILE))
sys.exit(1)
# if we are here the file was not created
if not os.path.isfile(constants.INIT_FILE):
Printer.print_error(
"Something went wrong, init command did not create a file.\n"
"Possible reasons: you don't have the write to create the file.")
sys.exit(1)
# file was already there, let's check if the project passed correspond to this file
try:
PolyaxonFile(constants.INIT_FILE).specification
except (PolyaxonfileError, ValidationError) as e:
Printer.print_error(
"Something went wrong, init command did not create a file.\n"
"Another file already exist with.")
Printer.print_error('Error message: `{}`.'.format(e))
sys.exit(1)
# At this point we check if we need to re init configurations
ProjectManager.purge()
ProjectManager.set_config(project_config, init=True)
IgnoreManager.init_config()
Printer.print_success(
"Project `{}` was initialized and Polyaxonfile was created successfully `{}`"
.format(project, constants.INIT_FILE))
def run(ctx, name, user, project_name, description, tags, specification, ttl,
upload, log, can_upload):
project_client = PolyaxonClient().project
def run_experiment():
click.echo('Creating an independent experiment.')
experiment = ExperimentConfig(
name=name,
description=description,
tags=tags,
content=specification.raw_data,
ttl=ttl,
is_managed=True,
)
try:
response = PolyaxonClient().project.create_experiment(
user, project_name, experiment)
cache.cache(config_manager=ExperimentManager, response=response)
Printer.print_success('Experiment `{}` was created'.format(
response.id))
except (PolyaxonHTTPError, PolyaxonShouldExitError,
PolyaxonClientException) as e:
Printer.print_error('Could not create experiment.')
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
def run_group():
click.echo(
'Creating an experiment group with the following definition:')
experiments_def = specification.experiments_def
get_group_experiments_info(**experiments_def)
experiment_group = GroupConfig(
name=name,
description=description,
tags=tags,
content=specification.raw_data,
is_managed=True,
)
try:
response = project_client.create_experiment_group(
user, project_name, experiment_group)
cache.cache(config_manager=GroupManager, response=response)
Printer.print_success('Experiment group {} was created'.format(
response.id))
except (PolyaxonHTTPError, PolyaxonShouldExitError,
PolyaxonClientException) as e:
Printer.print_error('Could not create experiment group.')
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
def run_job():
click.echo('Creating a job.')
job = JobConfig(
name=name,
description=description,
tags=tags,
content=specification.raw_data,
ttl=ttl,
is_managed=True,
)
try:
response = project_client.create_job(user, project_name, job)
cache.cache(config_manager=JobManager, response=response)
Printer.print_success('Job {} was created'.format(response.id))
except (PolyaxonHTTPError, PolyaxonShouldExitError,
PolyaxonClientException) as e:
Printer.print_error('Could not create job.')
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
def run_build():
click.echo('Creating a build.')
job = BuildJobConfig(
name=name,
description=description,
tags=tags,
content=specification.raw_data,
ttl=ttl,
is_managed=True,
)
try:
response = project_client.create_build(user, project_name, job)
cache.cache(config_manager=BuildJobManager, response=response)
Printer.print_success('Build {} was created'.format(response.id))
except (PolyaxonHTTPError, PolyaxonShouldExitError,
PolyaxonClientException) as e:
Printer.print_error('Could not create build.')
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
# Check if we need to upload
if upload:
if can_upload:
Printer.print_error(
'Uploading is not supported when switching project context!')
click.echo(
'Please, either omit the `-u` option or `-p` / `--project=` option.'
)
sys.exit(1)
ctx.invoke(upload_cmd, sync=False)
logs_cmd = None
if specification.is_experiment:
run_experiment()
logs_cmd = experiment_logs
elif specification.is_group:
run_group()
elif specification.is_job:
run_job()
logs_cmd = job_logs
elif specification.is_build:
run_build()
logs_cmd = build_logs
# Check if we need to invoke logs
if log and logs_cmd:
ctx.obj = {'project': '{}/{}'.format(user, project_name)}
ctx.invoke(logs_cmd)