def teardown_on_kubernetes(self, hooks):
args = ["delete", "--purge", "polyaxon"]
if not hooks:
args += ["--no-hooks"]
click.echo("Running teardown command ...")
self.helm.execute(args=args)
Printer.print_success("Deployment successfully deleted.")
def delete(ctx):
"""Delete project.
Uses /docs/core/cli/#caching
"""
owner, project_name = get_project_or_local(ctx.obj.get("project"),
is_cli=True)
if not click.confirm("Are sure you want to delete project `{}/{}`".format(
owner, project_name)):
click.echo("Existing without deleting project.")
sys.exit(1)
try:
polyaxon_client = ProjectClient(owner=owner, project=project_name)
response = polyaxon_client.delete()
local_project = ProjectManager.get_config()
if local_project and (owner, project_name) == (
local_project.user,
local_project.name,
):
# Purge caching
ProjectManager.purge()
except (ApiException, HTTPError) as e:
handle_cli_error(e,
message="Could not delete project `{}/{}`.".format(
owner, project_name))
sys.exit(1)
if response.status_code == 204:
Printer.print_success("Project `{}/{}` was delete successfully".format(
owner, project_name))
def deploy(config_file, manager_path, check, dry_run):
"""Deploy polyaxon."""
config = read_deployment_config(config_file)
manager = DeployManager(config=config,
filepath=config_file,
manager_path=manager_path,
dry_run=dry_run)
exception = None
if check:
try:
manager.check()
except Exception as e:
handle_cli_error(e,
message="Polyaxon deployment file is not valid.")
sys.exit(1)
Printer.print_success("Polyaxon deployment file is valid.")
else:
try:
manager.install()
except Exception as e:
Printer.print_error("Polyaxon could not be installed.")
exception = e
if exception:
Printer.print_error("Error message: {}.".format(exception))
def resume(ctx, polyaxonfile):
"""Resume run.
Uses /docs/core/cli/#caching
Examples:
\b
$ polyaxon ops --uid=8aac02e3a62a4f0aaa257c59da5eab80 resume
"""
content = None
if polyaxonfile:
content = "{}".format(ConfigSpec.read_from(polyaxonfile))
owner, project_name, run_uuid = get_project_run_or_local(
ctx.obj.get("project"), ctx.obj.get("run_uuid"), is_cli=True,
)
try:
polyaxon_client = RunClient(
owner=owner, project=project_name, run_uuid=run_uuid
)
response = polyaxon_client.resume(override_config=content)
Printer.print_success("Run was resumed with uid {}".format(response.uuid))
except (ApiException, HTTPError) as e:
handle_cli_error(e, message="Could not resume run `{}`.".format(run_uuid))
sys.exit(1)
def deploy(config_file, deployment_type, manager_path, check, dry_run):
"""Deploy polyaxon."""
config = read_deployment_config(config_file)
manager = DeployManager(
config=config,
filepath=config_file,
deployment_type=deployment_type,
manager_path=manager_path,
dry_run=dry_run,
)
exception = None
if config:
Printer.print_success("Polyaxon `{}` deployment file is valid.".format(
config.deployment_chart))
if check:
try:
manager.check()
except Exception as e:
handle_cli_error(e,
message="Polyaxon deployment manager error.",
sys_exit=True)
else:
try:
manager.install()
except Exception as e:
Printer.print_error("Polyaxon could not be installed.")
exception = e
if exception:
Printer.print_error("Error message: {}.".format(exception),
sys_exit=True)
def approve(ctx, project, uid):
"""Approve a run waiting for human validation.
Uses /docs/core/cli/#caching
Examples:
\b
$ polyaxon ops approve
\b
$ polyaxon ops approve --uid=8aac02e3a62a4f0aaa257c59da5eab80
"""
owner, project_name, run_uuid = get_project_run_or_local(
project or ctx.obj.get("project"),
uid or ctx.obj.get("run_uuid"),
is_cli=True,
)
try:
polyaxon_client = RunClient(owner=owner,
project=project_name,
run_uuid=run_uuid)
polyaxon_client.approve()
except (ApiException, HTTPError) as e:
handle_cli_error(
e, message="Could not approve run `{}`.".format(run_uuid))
sys.exit(1)
Printer.print_success("Run is approved")
def delete(ctx):
"""Delete a run.
Uses /docs/core/cli/#caching
Example:
\b
$ polyaxon ops delete
\b
$ polyaxon ops --uid=8aac02e3a62a4f0aaa257c59da5eab80 delete # project is cached
\b
$ polyaxon ops --project=cats-vs-dogs -uid 8aac02e3a62a4f0aaa257c59da5eab80 delete
"""
owner, project_name, run_uuid = get_project_run_or_local(
ctx.obj.get("project"), ctx.obj.get("run_uuid"), is_cli=True,
)
if not click.confirm("Are sure you want to delete run `{}`".format(run_uuid)):
click.echo("Existing without deleting the run.")
sys.exit(1)
try:
polyaxon_client = RunClient(
owner=owner, project=project_name, run_uuid=run_uuid
)
polyaxon_client.delete()
# Purge caching
RunManager.purge()
except (ApiException, HTTPError) as e:
handle_cli_error(e, message="Could not delete run `{}`.".format(run_uuid))
sys.exit(1)
Printer.print_success("Run `{}` was delete successfully".format(run_uuid))
def delete(component, version):
"""Delete a component hub or a component version."""
owner, component_hub, component_version, is_version = get_info(
component, version)
full_entity = ("{}/{}:{}".format(owner, component_hub, component_version)
if is_version else "{}/{}".format(owner, component_hub))
if not click.confirm(
"Are sure you want to delete component {} `{}`".format(
"version" if is_version else "hub", full_entity)):
click.echo("Existing without deleting component hub.")
sys.exit(1)
try:
polyaxon_client = PolyaxonClient()
if is_version:
polyaxon_client.component_hub_v1.delete_component_version(
owner, component_hub, component_version)
else:
polyaxon_client.component_hub_v1.delete_component_hub(
owner, component_hub)
Printer.print_success(
"Component {} `{}` was delete successfully".format(
"version" if is_version else "hub", full_entity))
except (ApiException, HTTPError) as e:
handle_cli_error(
e,
message="Could not delete component {} `{}`.".format(
"version" if is_version else "hub", full_entity),
)
sys.exit(1)
def update(component, version, name, description, tags, private):
"""Update component hub.
Uses /docs/core/cli/#caching
Example:
\b
$ polyaxon hub update foobar --description="Image Classification with DL using TensorFlow"
\b
$ polyaxon hub update mike1/foobar --description="Image Classification with DL using TensorFlow"
\b
$ polyaxon hub update --tags="foo, bar"
"""
owner, component_hub, component_version, is_version = get_info(
component, version)
full_entity = ("{}/{}:{}".format(owner, component_hub, component_version)
if is_version else "{}/{}".format(owner, component_hub))
update_dict = {}
if name:
update_dict["name"] = name
if description:
update_dict["description"] = description
tags = validate_tags(tags)
if tags:
update_dict["tags"] = tags
if private is not None:
update_dict["is_public"] = not private
if not update_dict:
Printer.print_warning(
"No argument was provided to update the component {}.".format(
"version" if is_version else "hub"))
sys.exit(1)
try:
polyaxon_client = PolyaxonClient()
if is_version:
response = polyaxon_client.component_hub_v1.patch_component_version(
owner, component_hub, component_version, body=update_dict)
Printer.print_success("Component version updated.")
get_component_version_details(response)
else:
response = polyaxon_client.component_hub_v1.patch_component_hub(
owner, component_hub, body=update_dict)
Printer.print_success("Component updated.")
get_entity_details(response, "Component hub")
except (ApiException, HTTPError) as e:
handle_cli_error(
e,
message="Could not update component {} `{}`.".format(
"version" if is_version else "hub", full_entity),
)
sys.exit(1)
def delete(model, version):
"""Delete a model registry or a model version."""
owner, model_registry, model_version, is_version = get_info(model, version)
full_entity = ("{}/{}:{}".format(owner, model_registry, model_version)
if is_version else "{}/{}".format(owner, model_registry))
if not click.confirm("Are sure you want to delete model {} `{}`".format(
"version" if is_version else "registry", full_entity)):
click.echo("Existing without deleting model registry.")
sys.exit(1)
try:
polyaxon_client = PolyaxonClient()
if is_version:
polyaxon_client.model_registry_v1.delete_model_version(
owner, model_registry, model_version)
else:
polyaxon_client.model_registry_v1.delete_model_registry(
owner, model_registry)
Printer.print_success("Model {} `{}` was delete successfully".format(
"version" if is_version else "registry", full_entity))
except (ApiException, HTTPError) as e:
handle_cli_error(
e,
message="Could not delete model {} `{}`.".format(
"version" if is_version else "registry", full_entity),
)
sys.exit(1)
def create(ctx, name, owner, description, private, init):
"""Create a new project.
Uses /docs/core/cli/#caching
Example:
\b
$ polyaxon project create --name=cats-vs-dogs --description="Image Classification with DL"
"""
owner = owner or AuthConfigManager.get_value("username")
if not owner:
Printer.print_error(
"Please login first or provide a valid owner --owner. "
"`polyaxon login --help`")
sys.exit(1)
try:
project_config = V1Project(name=name,
description=description,
is_public=not private)
_project = ProjectClient(owner=owner).create(project_config)
except (ApiException, HTTPError) as e:
handle_cli_error(e,
message="Could not create project `{}`.".format(name))
sys.exit(1)
Printer.print_success("Project `{}` was created successfully.".format(
_project.name))
if init:
ctx.obj = {}
ctx.invoke(init_project, project=name)
def artifacts(ctx):
"""Download outputs/artifacts for run.
Uses /docs/core/cli/#caching
Examples:
\b
$ polyaxon ops -uid=8aac02e3a62a4f0aaa257c59da5eab80 artifacts
"""
owner, project_name, run_uuid = get_project_run_or_local(
ctx.obj.get("project"),
ctx.obj.get("run_uuid"),
is_cli=True,
)
try:
client = RunClient(owner=owner,
project=project_name,
run_uuid=run_uuid)
client.download_artifacts()
except (ApiException, HTTPError) as e:
handle_cli_error(
e,
message="Could not download outputs for run `{}`.".format(
run_uuid))
sys.exit(1)
Printer.print_success("Files downloaded.")
def restart(ctx, copy, polyaxonfile, u):
"""Restart run.
Uses [Caching](/references/polyaxon-cli/#caching)
Examples:
\b
```bash
$ polyaxon run --uid=8aac02e3a62a4f0aaa257c59da5eab80 restart
```
"""
content = None
if polyaxonfile:
content = "{}".format(reader.read(polyaxonfile))
# Check if we need to upload
if u:
ctx.invoke(upload, sync=False)
owner, project_name, run_uuid = get_project_run_or_local(
ctx.obj.get("project"), ctx.obj.get("run_uuid"), is_cli=True)
try:
polyaxon_client = RunClient(owner=owner,
project=project_name,
run_uuid=run_uuid)
response = polyaxon_client.restart(override_config=content, copy=copy)
Printer.print_success("Run was {} with uid {}".format(
"copied" if copy else "restarted", response.uuid))
except (ApiException, HTTPError) as e:
handle_cli_error(
e, message="Could not restart run `{}`.".format(run_uuid))
sys.exit(1)
def create_run():
click.echo("Creating a run.")
try:
compiled_operation = OperationSpecification.compile_operation(
op_spec)
run_name = compiled_operation.name or name
resource = compiler.make(
owner_name=owner,
project_name=project_name,
project_uuid=project_name,
run_uuid=run_name,
run_name=name,
run_path=run_name,
compiled_operation=compiled_operation,
params=op_spec.params,
default_sa=settings.AGENT_CONFIG.runs_sa,
)
Spawner(namespace=settings.AGENT_CONFIG.namespace).create(
run_uuid=run_name,
run_kind=compiled_operation.get_run_kind(),
resource=resource,
)
# cache.cache(config_manager=RunConfigManager, response=response)
run_job_uid = get_resource_name(run_name)
Printer.print_success(
"A new run `{}` was created".format(run_job_uid))
except (PolyaxonCompilerError, PolyaxonK8SError,
PolypodException) as e:
handle_cli_error(e, message="Could not create a run.")
sys.exit(1)
def upgrade_on_kubernetes(self):
args = ["upgrade", self.release_name]
if self.manager_path:
args += [self.manager_path]
else:
args += [self.k8s_chart]
if self.filepath:
args += ["-f", self.filepath]
if self.type and self.type in [
DeploymentTypes.MICRO_K8S,
DeploymentTypes.MINIKUBE,
]:
args += [
"--set",
"gateway.service.type=NodePort,deploymentType={}".format(
self.type),
]
if self.deployment_version:
args += ["--version", self.deployment_version]
args += ["--namespace={}".format(self.deployment_namespace)]
if self.dry_run:
args += ["--debug", "--dry-run"]
click.echo("Running upgrade command ...")
stdout = self.helm.execute(args=args,
stream=settings.CLIENT_CONFIG.debug)
click.echo(stdout)
Printer.print_success("Deployment upgraded.")
def set(**kwargs): # pylint:disable=redefined-builtin
"""Set the global config values.
Example:
\b
$ polyaxon config set --host=localhost
"""
try:
_config = ClientConfigManager.get_config_or_default()
except Exception as e:
handle_cli_error(e, message="Polyaxon load configuration.")
Printer.print_header(
"You can reset your config by running: polyaxon config purge"
)
sys.exit(1)
for key, value in kwargs.items():
if value is not None:
setattr(_config, key, value)
ClientConfigManager.set_config(_config)
Printer.print_success("Config was updated.")
# Reset cli config
CliConfigManager.purge()
def upload(ctx, project, uid, path_from, path_to, is_file, sync_failure):
"""Upload runs' artifacts.
Uses /docs/core/cli/#caching
Examples:
\b
$ polyaxon ops upload -uid=8aac02e3a62a4f0aaa257c59da5eab80
\b
$ polyaxon ops upload -uid=8aac02e3a62a4f0aaa257c59da5eab80 path_from="path/to/upload"
\b
$ polyaxon ops upload -uid=8aac02e3a62a4f0aaa257c59da5eab80 path_to="path/to/upload/to"
"""
owner, project_name, run_uuid = get_project_run_or_local(
project or ctx.obj.get("project"),
uid or ctx.obj.get("run_uuid"),
is_cli=True,
)
try:
client = RunClient(owner=owner,
project=project_name,
run_uuid=run_uuid)
if is_file:
response = client.upload_artifact(filepath=path_from,
path=path_to,
overwrite=True)
else:
response = client.upload_artifacts_dir(
dirpath=path_from,
path=path_to,
overwrite=True,
relative_to=path_from,
)
except (
ApiException,
HTTPError,
PolyaxonHTTPError,
PolyaxonShouldExitError,
PolyaxonClientException,
) as e:
handle_cli_error(
e,
message="Could not upload artifacts for run `{}`".format(run_uuid))
sys.exit(1)
if response.status_code == 200:
Printer.print_success("Artifacts uploaded")
else:
if sync_failure:
client.log_failed(reason="OperationCli",
message="Operation failed uploading artifacts")
Printer.print_error(
"Error uploading artifacts. "
"Status: {}. Error: {}.".format(response.status_code,
response.content),
sys_exit=True,
)
def stop(ctx, yes):
"""Stop run.
Uses [Caching](/references/polyaxon-cli/#caching)
Examples:
\b
```bash
$ polyaxon runs stop
```
\b
```bash
$ polyaxon runs --uid=8aac02e3a62a4f0aaa257c59da5eab80 stop
```
"""
owner, project_name, run_uuid = get_project_run_or_local(
ctx.obj.get("project"), ctx.obj.get("run_uuid"))
if not yes and not click.confirm("Are sure you want to stop "
"run `{}`".format(run_uuid)):
click.echo("Existing without stopping run.")
sys.exit(0)
try:
polyaxon_client = PolyaxonClient()
polyaxon_client.runs_v1.stop_run(owner, project_name, run_uuid)
except (ApiException, HTTPError) as e:
handle_cli_error(e,
message="Could not stop run `{}`.".format(run_uuid))
sys.exit(1)
Printer.print_success("Run is being stopped.")
def invalidate(ctx, project, uid):
"""Invalidate the run's cache state.
Uses /docs/core/cli/#caching
Examples:
\b
$ polyaxon ops invalidate
"""
owner, project_name, run_uuid = get_project_run_or_local(
project or ctx.obj.get("project"),
uid or ctx.obj.get("run_uuid"),
is_cli=True,
)
try:
polyaxon_client = RunClient(owner=owner,
project=project_name,
run_uuid=run_uuid)
response = polyaxon_client.invalidate()
Printer.print_success("Run was invalidated with uid {}".format(
response.uuid))
except (ApiException, HTTPError) as e:
handle_cli_error(
e, message="Could not invalidate run `{}`.".format(run_uuid))
sys.exit(1)
def resume(ctx, polyaxonfile, u):
"""Resume run.
Uses [Caching](/references/polyaxon-cli/#caching)
Examples:
\b
```bash
$ polyaxon runs --uid=8aac02e3a62a4f0aaa257c59da5eab80 resume
```
"""
content = None
if polyaxonfile:
content = "{}".format(rhea.read(polyaxonfile))
# Check if we need to upload
if u:
ctx.invoke(upload, sync=False)
owner, project_name, run_uuid = get_project_run_or_local(
ctx.obj.get("project"), ctx.obj.get("run_uuid"))
try:
polyaxon_client = PolyaxonClient()
body = V1Run(content=content)
response = polyaxon_client.runs_v1.resume_run(owner, project_name,
run_uuid, body)
Printer.print_success("Run was resumed with uid {}".format(
response.uuid))
except (ApiException, HTTPError) as e:
handle_cli_error(e,
message="Could not resume run `{}`.".format(run_uuid))
sys.exit(1)
def stop(ctx, yes):
"""Stop run.
Uses /docs/core/cli/#caching
Examples:
\b
$ polyaxon ops stop
\b
$ polyaxon ops --uid=8aac02e3a62a4f0aaa257c59da5eab80 stop
"""
owner, project_name, run_uuid = get_project_run_or_local(
ctx.obj.get("project"), ctx.obj.get("run_uuid"), is_cli=True,
)
if not yes and not click.confirm(
"Are sure you want to stop " "run `{}`".format(run_uuid)
):
click.echo("Existing without stopping run.")
sys.exit(0)
try:
polyaxon_client = RunClient(
owner=owner, project=project_name, run_uuid=run_uuid
)
polyaxon_client.stop()
except (ApiException, HTTPError) as e:
handle_cli_error(e, message="Could not stop run `{}`.".format(run_uuid))
sys.exit(1)
Printer.print_success("Run is being stopped.")
def invalidate_run(ctx):
"""Invalidate runs' cache inside this project.
Uses [Caching](/references/polyaxon-cli/#caching)
Examples:
\b
```bash
$ polyaxon invalidate_builds
```
"""
owner, project_name, run_uuid = get_project_run_or_local(
ctx.obj.get("project"), ctx.obj.get("run_uuid"))
try:
polyaxon_client = PolyaxonClient()
response = polyaxon_client.runs_v1.invalidate_run(
owner, project_name, run_uuid)
Printer.print_success("Run was invalidated with uid {}".format(
response.uuid))
except (ApiException, HTTPError) as e:
handle_cli_error(
e, message="Could not invalidate run `{}`.".format(run_uuid))
sys.exit(1)
def artifacts(ctx, path, path_to, no_untar):
"""Download outputs/artifacts for run.
Uses /docs/core/cli/#caching
Examples:
\b
$ polyaxon ops -uid=8aac02e3a62a4f0aaa257c59da5eab80 artifacts
\b
$ polyaxon ops -uid=8aac02e3a62a4f0aaa257c59da5eab80 artifacts path="events/only"
\b
$ polyaxon ops -uid=8aac02e3a62a4f0aaa257c59da5eab80 artifacts path_to="this/path"
"""
owner, project_name, run_uuid = get_project_run_or_local(
ctx.obj.get("project"), ctx.obj.get("run_uuid"), is_cli=True,
)
try:
client = RunClient(owner=owner, project=project_name, run_uuid=run_uuid)
download_path = client.download_artifacts(
path=path or "", path_to=path_to, untar=not no_untar
)
except (ApiException, HTTPError) as e:
handle_cli_error(
e, message="Could not download outputs for run `{}`.".format(run_uuid)
)
sys.exit(1)
Printer.print_success("Files downloaded: path: {}".format(download_path))
def unbookmark(ctx):
"""Unbookmark run.
Uses [Caching](/references/polyaxon-cli/#caching)
Examples:
\b
```bash
$ polyaxon runs unbookmark
```
\b
```bash
$ polyaxon runs -uid=8aac02e3a62a4f0aaa257c59da5eab80 unbookmark
```
"""
owner, project_name, run_uuid = get_project_run_or_local(
ctx.obj.get("project"), ctx.obj.get("run_uuid"))
try:
polyaxon_client = PolyaxonClient()
polyaxon_client.runs_v1.unbookmark_run(owner, project_name, run_uuid)
except (ApiException, HTTPError) as e:
handle_cli_error(
e, message="Could not unbookmark run `{}`.".format(run_uuid))
sys.exit(1)
Printer.print_success("Run is unbookmarked.")
def install_on_docker_compose(self):
path = ComposeConfigManager.get_config_filepath()
path = "/".join(path.split("/")[:-1])
# Fetch docker-compose
Transport().download(
url=
"https://github.com/polyaxon/polyaxon-compose/archive/master.tar.gz",
filename=path + "/file",
untar=True,
delete_tar=True,
extract_path=path,
)
# Move necessary info
shutil.copy(
path + "/polyaxon-compose-master/docker-compose.yml",
path + "/docker-compose.yml",
)
shutil.copy(path + "/polyaxon-compose-master/components.env",
path + "/components.env")
shutil.copy(path + "/polyaxon-compose-master/base.env",
path + "/base.env")
shutil.rmtree(path + "/polyaxon-compose-master/")
# Generate env from config
ComposeConfigManager.set_config(self.compose.generate_env(self.config))
Printer.print_success("Docker Compose deployment is initialised.")
if self.dry_run:
Printer.print_success("Polyaxon generated deployment env.")
return
self.docker.execute(["volume", "create", "--name=polyaxon-postgres"])
Printer.print_success("Docker volume created.")
self.compose.execute(["-f", path + "/docker-compose.yml", "up", "-d"])
Printer.print_success("Deployment is running in the background.")
Printer.print_success("You can configure your CLI by running: "
"polyaxon config set --host=localhost.")
def restart(ctx, project, uid, copy, polyaxonfile):
"""Restart run.
Uses /docs/core/cli/#caching
Examples:
\b
$ polyaxon run --uid=8aac02e3a62a4f0aaa257c59da5eab80 restart
"""
content = None
if polyaxonfile:
content = OperationSpecification.read(
polyaxonfile, is_preset=True).to_dict(dump=True)
owner, project_name, run_uuid = get_project_run_or_local(
project or ctx.obj.get("project"),
uid or ctx.obj.get("run_uuid"),
is_cli=True,
)
try:
polyaxon_client = RunClient(owner=owner,
project=project_name,
run_uuid=run_uuid)
response = polyaxon_client.restart(override_config=content, copy=copy)
Printer.print_success("Run was {} with uid {}".format(
"copied" if copy else "restarted", response.uuid))
except (ApiException, HTTPError) as e:
handle_cli_error(
e, message="Could not restart run `{}`.".format(run_uuid))
sys.exit(1)
def upload(sync=True): # pylint:disable=assign-to-new-keyword
"""Upload code of the current directory while respecting the .polyaxonignore file."""
project = ProjectManager.get_config_or_raise()
files = IgnoreManager.get_unignored_filepaths()
try:
with create_project_tarfile(files, project.name) as filepath:
with get_files_by_paths("repo", [filepath]) as (files, files_size):
try:
PolyaxonClient().project.upload_repo(project.user,
project.name,
files,
files_size,
sync=sync)
except (
PolyaxonHTTPError,
PolyaxonShouldExitError,
PolyaxonClientException,
) as e:
handle_cli_error(
e,
message="Could not upload code for project `{}`.".
format(project.name),
)
Printer.print_error(
"Check the project exists, "
"and that you have access rights, "
"this could happen as well when uploading large files. "
"Please also make sure that you have enough space to upload the data."
)
sys.exit(1)
Printer.print_success("Files uploaded.")
except Exception as e:
handle_cli_error(e, message="Could not upload the file.")
sys.exit(1)
def upgrade(config_file, deployment_type, manager_path, check, dry_run):
"""Upgrade a Polyaxon deployment."""
config = read_deployment_config(config_file, command="upgrade")
manager = DeployConfigManager(
config=config,
filepath=config_file,
deployment_type=deployment_type,
manager_path=manager_path,
dry_run=dry_run,
)
exception = None
if config:
Printer.print_success("Polyaxon `{}` deployment file is valid.".format(
config.deployment_chart))
if check:
try:
manager.check()
except Exception as e:
handle_cli_error(e,
message="Polyaxon deployment manager error.",
sys_exit=True)
else:
try:
manager.upgrade()
except Exception as e:
Printer.print_error("Polyaxon could not upgrade the deployment.")
exception = e
if exception:
Printer.print_error("Error message: {}.".format(exception))
def check_polyaxonfile(polyaxonfile,
params=None,
profile=None,
queue=None,
nocache=None,
log=True):
if not polyaxonfile:
polyaxonfile = PolyaxonFile.check_default_path(path=".")
if not polyaxonfile:
polyaxonfile = ""
polyaxonfile = to_list(polyaxonfile)
exists = [os.path.isfile(f) for f in polyaxonfile]
parsed_params = None
if params:
parsed_params = parse_params(params)
if not any(exists):
Printer.print_error("Polyaxonfile is not present, "
"please run {}".format(constants.INIT_COMMAND))
sys.exit(1)
try:
plx_file = PolyaxonFile(polyaxonfile)
plx_file = plx_file.get_op_specification(params=parsed_params,
profile=profile,
queue=queue,
nocache=nocache)
if log:
Printer.print_success("Polyaxonfile valid")
return plx_file
except Exception as e:
handle_cli_error(e, message="Polyaxonfile is not valid.")
sys.exit(1)
def create_run():
click.echo("Creating a run.")
try:
polyaxon_client = RunClient(owner=owner, project=project_name)
response = polyaxon_client.create(
name=name, description=description, tags=tags, content=op_spec
)
config = polyaxon_client.client.sanitize_for_serialization(response)
cache.cache(
config_manager=RunManager,
config=config,
owner=owner,
project=project_name,
)
Printer.print_success("A new run `{}` was created".format(response.uuid))
click.echo(
"You can view this run on Polyaxon UI: {}".format(
get_dashboard_url(
subpath="{}/{}/runs/{}".format(
owner, project_name, response.uuid
)
)
)
)
except (ApiException, HTTPError) as e:
handle_cli_error(e, message="Could not create a run.")
sys.exit(1)
