def url(ctx):
"""Prints the notebook url for this project.
Uses [Caching](/polyaxon_cli/introduction#Caching)
Example:
\b
```bash
$ polyaxon notebook url
```
"""
user, project_name = get_project_or_local(ctx.obj.get('project'))
try:
response = PolyaxonClient().project.get_project(user, 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_notebook:
click.echo(get_notebook_url(user, project_name))
else:
Printer.print_warning(
'This project `{}` does not have a running notebook.'.format(
project_name))
click.echo(
'You can start a notebook with this command: polyaxon notebook start --help'
)
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 stop(ctx, commit, yes):
"""Stops the notebook deployment for this project if it exists.
Uses [Caching](/polyaxon_cli/introduction#Caching)
"""
user, project_name = get_project_or_local(ctx.obj.get('project'))
if not yes and not click.confirm("Are sure you want to stop notebook "
"for project `{}/{}`".format(
user, project_name)):
click.echo('Existing without stopping notebook.')
sys.exit(1)
if commit is None:
commit = True
try:
PolyaxonClient().project.stop_notebook(user, project_name, commit)
Printer.print_success('Notebook is being deleted')
except (PolyaxonHTTPError, PolyaxonShouldExitError,
PolyaxonClientException) as e:
Printer.print_error(
'Could not stop notebook project `{}`.'.format(project_name))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
def url(ctx):
"""Prints the tensorboard url for this project.
Uses [Caching](/polyaxon_cli/introduction#Caching)
Example:
\b
```bash
$ polyaxon tensorboard url
```
"""
user, project_name = get_project_or_local(ctx.obj['project'])
try:
response = PolyaxonClients().project.get_project(user, project_name)
except (PolyaxonHTTPError, PolyaxonShouldExitError) 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, project_name))
else:
Printer.print_warning(
'This project `{}` does not have a running tensorboard.'.format(
project_name))
click.echo(
'You can start tensorboard with this command: polyaxon tensorboard start'
)
def start(ctx, file): # pylint:disable=redefined-builtin
"""Start a tensorboard deployment for this project.
It will show a tensorboard with all experiments under the project.
Uses [Caching](/polyaxon_cli/introduction#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 ...
```
"""
specification = None
plugin_job = None
if file:
specification = check_polyaxonfile(file, log=False).specification
if specification:
# pylint:disable=protected-access
check_polyaxonfile_kind(specification=specification,
kind=specification._PLUGIN)
plugin_job = PluginJobConfig(config=specification.parsed_data)
user, project_name = get_project_or_local(ctx.obj['project'])
try:
response = PolyaxonClients().project.start_tensorboard(
user, project_name, plugin_job)
except (PolyaxonHTTPError, PolyaxonShouldExitError) 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 notebook for this project is already running on:")
click.echo(get_tensorboard_url(user, project_name))
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 project `{}`'.format(project_name))
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))
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 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 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 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
plugin_job = None
if file:
specification = check_polyaxonfile(file, log=False).specification
# Check if we need to upload
if u:
ctx.invoke(upload, async=False)
if specification:
# pylint:disable=protected-access
check_polyaxonfile_kind(specification=specification,
kind=specification._PLUGIN)
plugin_job = PluginJobConfig(config=specification.parsed_data)
user, project_name = get_project_or_local(ctx.obj['project'])
try:
response = PolyaxonClients().project.start_notebook(
user, project_name, plugin_job)
except (PolyaxonHTTPError, PolyaxonShouldExitError) 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 init(project, run, model):
"""Initialize a new polyaxonfile specification."""
user, project_name = get_project_or_local(project)
try:
project_config = PolyaxonClients().project.get_project(user, project_name)
except (PolyaxonHTTPError, PolyaxonShouldExitError) as e:
Printer.print_error('Make sure you have a project with this name `{}`'.format(project))
Printer.print_error('You can a new project with this command: '
'polyaxon project create --name={} --description=...'.format(project))
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 an 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.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.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 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 logs(experiment, project):
"""Get experiment logs.
Examples:
```
polyaxon experiment logs 1
```
"""
user, project_name = get_project_or_local(project)
try:
PolyaxonClients().experiment.logs(user,
project_name,
experiment,
message_handler=click.echo)
except (PolyaxonHTTPError, PolyaxonShouldExitError) as e:
Printer.print_error(
'Could not get logs for experiment `{}`.'.format(experiment))
# Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
def logs(experiment, job, project):
"""Get job logs.
Examples:
```
polyaxon job logs 50c62372137940ca8c456d8596946dd7
```
"""
user, project_name = get_project_or_local(project)
try:
PolyaxonClients().job.logs(user,
project_name,
experiment,
job,
message_handler=click.echo)
except (PolyaxonHTTPError, PolyaxonShouldExitError) as e:
Printer.print_error('Could not get logs for job `{}`.'.format(job))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
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 delete(group, project):
"""Delete experiment group."""
user, project_name = get_project_or_local(project)
if not click.confirm(
"Are sure you want to delete experiment group `{}`".format(group)):
click.echo('Existing without deleting experiment group.')
sys.exit(0)
try:
response = PolyaxonClients().experiment_group.delete_experiment_group(
user, project_name, group)
except (PolyaxonHTTPError, PolyaxonShouldExitError) as e:
Printer.print_error(
'Could not delete experiment group `{}`.'.format(group))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
if response.status_code == 204:
Printer.print_success(
"Experiment group `{}` was delete successfully".format(group))
def get(group, project):
"""Get experiment group by uuid.
Examples:
```
polyaxon group get 13
```
"""
user, project_name = get_project_or_local(project)
try:
response = PolyaxonClients().experiment_group.get_experiment_group(
user, project_name, group)
except (PolyaxonHTTPError, PolyaxonShouldExitError) as e:
Printer.print_error(
'Could not get experiment group `{}`.'.format(group))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
response = response.to_dict()
Printer.print_header("Experiment group info:")
dict_tabulate(response)
def stop(ctx, yes):
"""Stops the tensorboard deployment for this project if it exists.
Uses [Caching](/polyaxon_cli/introduction#Caching)
"""
user, project_name = get_project_or_local(ctx.obj['project'])
if not yes and not click.confirm("Are sure you want to stop tensorboard "
"for project `{}/{}`".format(
user, project_name)):
click.echo('Existing without stopping tensorboard.')
sys.exit(1)
try:
PolyaxonClients().project.stop_tensorboard(user, project_name)
Printer.print_success('Tensorboard is being deleted')
except (PolyaxonHTTPError, PolyaxonShouldExitError) as e:
Printer.print_error(
'Could not stop tensorboard project `{}`.'.format(project_name))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
def statuses(experiment, project, page):
"""Get experiment status.
Examples:
```
polyaxon experiment status 3
```
"""
user, project_name = get_project_or_local(project)
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(
[o.to_dict() for o in response['results']])
if objects:
Printer.print_header("Statuses:")
objects.pop('experiment')
dict_tabulate(objects, is_list_dict=True)
def stop(experiment, project):
"""Get experiment by uuid.
Examples:
```
polyaxon group stop 2
```
"""
user, project_name = get_project_or_local(project)
if not click.confirm(
"Are sure you want to stop experiment `{}`".format(experiment)):
click.echo('Existing without stopping experiment.')
sys.exit(0)
try:
response = PolyaxonClients().experiment.stop(user, project_name,
experiment)
except (PolyaxonHTTPError, PolyaxonShouldExitError) as e:
Printer.print_error(
'Could not stop experiment `{}`.'.format(experiment))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
Printer.print_success("Experiment is being stopped.")
def get_group_or_local(project=None, group=None): # pylint:disable=redefined-outer-name
user, project_name = get_project_or_local(project)
group = group or GroupManager.get_config_or_raise().sequence
return user, project_name, group
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 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 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_content = None
if file:
specification = check_polyaxonfile(file, log=False).specification
if specification:
# pylint:disable=protected-access
check_polyaxonfile_kind(specification=specification,
kind=kinds.TENSORBOARD)
job_content = specification.raw_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,
content=job_content,
is_managed=True,
)
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,
content=job_content,
is_managed=True,
)
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,
content=job_content,
is_managed=True,
)
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))
indentation.puts(
"It may take some time before you can access tensorboard.\n")
indentation.puts("Your tensorboard will be available on:\n")
with indentation.indent(4):
indentation.puts(
get_tensorboard_url(user, project_name, experiment, group))
def start(ctx, file, u): # pylint:disable=redefined-builtin
"""Start a notebook deployment for this project.
Uses [Caching](/references/polyaxon-cli/#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_content = None
if file:
specification = check_polyaxonfile(file, log=False).specification
# Check if we need to upload
if u:
ctx.invoke(upload, sync=False)
if specification:
# pylint:disable=protected-access
check_polyaxonfile_kind(specification=specification,
kind=kinds.NOTEBOOK)
job_content = specification.raw_data
user, project_name = get_project_or_local(ctx.obj.get('project'))
try:
response = PolyaxonClient().project.start_notebook(
username=user,
project_name=project_name,
content=job_content,
is_managed=True,
)
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))
indentation.puts(
"It may take some time before you can access the notebook.\n")
indentation.puts("Your notebook will be available on:\n")
with indentation.indent(4):
indentation.puts(get_notebook_url(user, project_name))
def get_experiment_or_local(project=None, experiment=None): # pylint:disable=redefined-outer-name
user, project_name = get_project_or_local(project)
experiment = experiment or ExperimentManager.get_config_or_raise().sequence
return user, project_name, experiment
