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 log_tags(self,
tags: Union[str, Sequence[str]],
reset=False,
async_req=True):
patch_dict = {"tags": validate_tags(tags)}
if reset is False:
patch_dict["merge"] = True
self._update(patch_dict, async_req=async_req)
def create(ctx, name, description, tags, public, init):
"""Create a new project.
Uses /docs/core/cli/#caching
Example:
\b
$ polyaxon project create --name=cats-vs-dogs --description="Image Classification with DL"
\b
$ polyaxon project create --name=owner/name --description="Project Description"
"""
if not name:
Printer.print_error(
"Please provide a valid name to create a project.",
command_help="project create",
sys_exit=True,
)
owner, project_name = resolve_entity_info(name or ctx.obj.get("project"),
is_cli=True,
entity_name="project")
tags = validate_tags(tags)
if not owner:
Printer.print_error(
"Please provide a valid name with an owner namespace: --name=owner/project."
)
sys.exit(1)
try:
project_config = V1Project(name=project_name,
description=description,
tags=tags,
is_public=public)
polyaxon_client = ProjectClient(owner=owner)
_project = polyaxon_client.create(project_config)
config = polyaxon_client.client.sanitize_for_serialization(_project)
cache.cache(config_manager=ProjectConfigManager, config=config)
except (ApiException, HTTPError) as e:
handle_cli_error(
e, message="Could not create project `{}`.".format(project_name))
sys.exit(1)
Printer.print_success("Project `{}` was created successfully.".format(
_project.name))
click.echo("You can view this project on Polyaxon UI: {}".format(
get_dashboard_url(subpath="{}/{}".format(owner, _project.name))))
if init:
ctx.obj = {}
ctx.invoke(
init_project,
project="{}/{}".format(owner, project_name),
polyaxonignore=True,
)
def create(ctx, name, description, tags, private, init):
"""Create a new project.
Uses /docs/core/cli/#caching
Example:
\b
$ polyaxon project create --project=cats-vs-dogs --description="Image Classification with DL"
\b
$ polyaxon project create --project=owner/name --description="Project Description"
"""
if not name:
Printer.print_error(
"Please login provide a name to create a project.",
command_help="project create",
sys_exit=True,
)
owner, project_name = get_project_or_local(name or ctx.obj.get("project"),
is_cli=True)
owner = owner or settings.AUTH_CONFIG.username
if not owner and (not settings.CLI_CONFIG or settings.CLI_CONFIG.is_ce):
owner = DEFAULT
tags = validate_tags(tags)
if not owner:
Printer.print_error(
"Please login first or provide a valid name with owner --name=owner/project. "
"`polyaxon login --help`")
sys.exit(1)
try:
project_config = V1Project(name=project_name,
description=description,
tags=tags,
is_public=not private)
polyaxon_client = ProjectClient(owner=owner)
_project = polyaxon_client.create(project_config)
config = polyaxon_client.client.sanitize_for_serialization(_project)
cache.cache(config_manager=ProjectConfigManager, config=config)
except (ApiException, HTTPError) as e:
handle_cli_error(
e, message="Could not create project `{}`.".format(project_name))
sys.exit(1)
Printer.print_success("Project `{}` was created successfully.".format(
_project.name))
click.echo("You can view this project on Polyaxon UI: {}".format(
get_dashboard_url(subpath="{}/{}".format(owner, _project.name))))
if init:
ctx.obj = {}
ctx.invoke(init_project, project="{}/{}".format(owner, project_name))
def update(ctx, name, description, tags):
"""Update run.
Uses [Caching](/references/polyaxon-cli/#caching)
Examples:
\b
```bash
$ polyaxon runs --uid=8aac02e3a62a4f0aaa257c59da5eab80 update
--description="new description for my runs"
```
\b
```bash
$ polyaxon runs --project=cats-vs-dogs -id 8aac02e3a62a4f0aaa257c59da5eab80 update
--tags="foo, bar" --name="unique-name"
```
"""
owner, project_name, run_uuid = get_project_run_or_local(
ctx.obj.get("project"), ctx.obj.get("run_uuid"), is_cli=True)
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 not update_dict:
Printer.print_warning("No argument was provided to update the run.")
sys.exit(0)
try:
polyaxon_client = RunClient(owner=owner,
project=project_name,
run_uuid=run_uuid)
response = polyaxon_client.update(update_dict)
except (ApiException, HTTPError) as e:
handle_cli_error(e,
message="Could not update run `{}`.".format(run_uuid))
sys.exit(1)
Printer.print_success("Run updated.")
get_run_details(response)
def create(name, description, tags, public):
"""Create a new model.
Example:
\b
$ polyaxon registry create --name=kaniko --description="Tool to build container images"
\b
$ polyaxon registry create --name=owner/name --description="Model description"
"""
if not name:
Printer.print_error(
"Please provide a name to create a model registry.",
command_help="registry create",
sys_exit=True,
)
owner, registry_name, _, _ = get_info(name, None)
tags = validate_tags(tags)
if not owner or not registry_name:
Printer.print_error(
"Please provide a valid model name with --name=owner/registry-name. "
)
sys.exit(1)
try:
registry_config = V1ModelRegistry(
name=registry_name, description=description, tags=tags, is_public=public
)
polyaxon_client = PolyaxonClient()
_registry = polyaxon_client.model_registry_v1.create_model_registry(
owner, registry_config
)
except (ApiException, HTTPError) as e:
handle_cli_error(
e, message="Could not create model registry `{}`.".format(registry_name)
)
sys.exit(1)
Printer.print_success(
"Model registry `{}` was created successfully.".format(_registry.name)
)
click.echo(
"You can view this model registry on Polyaxon UI: {}".format(
get_dashboard_url(subpath="{}/registry/{}".format(owner, _registry.name))
)
)
def update(ctx, _project, name, description, tags, private):
"""Update project.
Uses /docs/core/cli/#caching
Example:
\b
$ polyaxon project update foobar --description="Image Classification with DL using TensorFlow"
\b
$ polyaxon project update mike1/foobar --description="Image Classification with DL using TensorFlow"
\b
$ polyaxon update --tags="foo, bar"
"""
owner, project_name = get_project_or_local(_project
or ctx.obj.get("project"),
is_cli=True)
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 project.")
sys.exit(1)
try:
polyaxon_client = ProjectClient(owner=owner)
response = polyaxon_client.update(update_dict)
except (ApiException, HTTPError) as e:
handle_cli_error(
e, message="Could not update project `{}`.".format(project_name))
sys.exit(1)
Printer.print_success("Project updated.")
get_entity_details(response, "Project")
def create(name, description, tags, public):
"""Create a new component.
Example:
\b
$ polyaxon hub create --name=kaniko --description="Tool to build container images"
\b
$ polyaxon hub create --name=owner/name --description="Component description"
"""
if not name:
Printer.print_error(
"Please provide a name to create a component hub.",
command_help="hub create",
sys_exit=True,
)
owner, hub_name, _, _ = get_info(name, None)
tags = validate_tags(tags)
if not owner or not hub_name:
Printer.print_error(
"Please provide a valid component name with --name=owner/hub-name. "
)
sys.exit(1)
try:
hub_config = V1ComponentHub(
name=hub_name, description=description, tags=tags, is_public=public
)
polyaxon_client = PolyaxonClient()
_hub = polyaxon_client.component_hub_v1.create_component_hub(owner, hub_config)
except (ApiException, HTTPError) as e:
handle_cli_error(
e, message="Could not create component hub `{}`.".format(hub_name)
)
sys.exit(1)
Printer.print_success(
"Component hub `{}` was created successfully.".format(_hub.name)
)
click.echo(
"You can view this component hub on Polyaxon UI: {}".format(
get_dashboard_url(subpath="{}/hub/{}".format(owner, _hub.name))
)
)
def log_tags(
self,
tags: Union[str, Sequence[str]],
reset: bool = False,
async_req: bool = True,
):
"""Logs new tags for the current run.
Args:
tags: str or List[str], tag or tags to log.
reset: bool, optional, if True, it will reset the whole tags state.
Note that Polyaxon will automatically populate the tags based
on the Polyaxonfile.
async_req: bool, optional, default: False, execute request asynchronously.
"""
patch_dict = {"tags": validate_tags(tags)}
if reset is False:
patch_dict["merge"] = True
self._update(patch_dict, async_req=async_req)
def create(ctx, name, owner, description, tags, 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")
tags = validate_tags(tags)
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,
tags=tags,
is_public=not private)
polyaxon_client = ProjectClient(owner=owner)
_project = polyaxon_client.create(project_config)
config = polyaxon_client.client.sanitize_for_serialization(
_project.project_data)
cache.cache(config_manager=ProjectManager, config=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 run(
ctx,
project,
polyaxonfile,
python_module,
url,
hub,
name,
tags,
description,
log,
watch,
local,
params,
presets,
queue,
nocache,
eager,
git_preset,
git_revision,
ignore_template,
):
"""Run polyaxonfile specification.
Examples:
\b
$ polyaxon run -f file -f file_override ...
Run and set description and tags for this run
\b
$ polyaxon run -f file --description="Description of the current run" --tags="foo, bar, moo"
Run and set a unique name for this run
\b
polyaxon run --name=foo
Run for a specific project
\b
$ polyaxon run -p project1 -f file.yaml
Run with updated params
\b
$ polyaxon run -p project1 -f file.yaml -P param1=234.2 -P param2=relu
If a python file contains a component main, you can run that component
\b
polyaxon run -pm path/to/my-component.py
If a python file contains more than one component, you can specify the component to run
\b
polyaxon run -pm path/to/my-component.py:componentA
"""
git_init = None
if git_preset:
# Check that the current path was initialized
if not GitConfigManager.is_initialized():
Printer.print_error(
"You can't use --git-init, "
"the current path is not initialized with a valid git connection or a git url, "
"please run `polyaxon init [--git-connection] [--git-url]` "
"to set a valid git configuration.")
sys.exit(1)
git_init = GitConfigManager.get_config()
if git_revision:
git_init.git.revision = git_revision
elif code_reference.is_git_initialized(path="."):
if code_reference.is_dirty(path="."):
Printer.print_warning(
"Polyaxon detected uncommitted changes in the current git repo!"
)
commit_hash = code_reference.get_commit()
git_init.git.revision = commit_hash
else:
Printer.print_warning(
"Polyaxon could not find a valid git repo, "
"and will not add the current commit to the git initializer.")
presets = validate_tags(presets)
op_spec = check_polyaxonfile(
polyaxonfile=polyaxonfile,
python_module=python_module,
url=url,
hub=hub,
params=params,
presets=presets,
queue=queue,
nocache=nocache,
verbose=False,
eager=eager,
git_init=git_init,
ignore_template=ignore_template,
)
if ignore_template:
op_spec.disable_template()
if op_spec.is_template():
click.echo(
"Please customize the specification or disable the template.")
sys.exit(1)
owner, project_name = get_project_or_local(project, is_cli=True)
tags = validate_tags(tags)
if local:
try:
compiled_operation = OperationSpecification.compile_operation(
op_spec)
compiled_operation = CompiledOperationSpecification.apply_operation_contexts(
compiled_operation)
except (PolyaxonSchemaError, ValidationError):
Printer.print_error(
"Could not run this polyaxonfile locally, "
"a context is required to resolve it dependencies.")
sys.exit(1)
docker_run(
ctx=ctx,
name=name,
owner=owner,
project_name=project_name,
description=description,
tags=tags,
compiled_operation=compiled_operation,
log=log,
)
elif settings.CLIENT_CONFIG.no_api:
k8s_run(
ctx=ctx,
name=name,
owner=owner,
project_name=project_name,
description=description,
tags=tags,
op_spec=op_spec,
log=log,
)
else:
platform_run(
ctx=ctx,
name=name,
owner=owner,
project_name=project_name,
description=description,
tags=tags,
op_spec=op_spec,
log=log,
watch=watch,
eager=eager,
)
def push(polyaxonfile, name, description, tags):
"""Push a new component version.
If the name corresponds to an existing component version, it will be updated.
Example:
\b
$ polyaxon hub push -f polyaxonfile.yaml --name=kaniko:latest --description="Tool to build container images"
\b
$ polyaxon hub push -f polyaxonfile.yaml --name=owner/name:v1 --description="Component description"
"""
if not name:
Printer.print_error(
"Please provide a name to create a component version.",
command_help="hub push",
sys_exit=True,
)
owner, hub_name, version, is_version = get_info(None, name)
tags = validate_tags(tags)
if not polyaxonfile or not os.path.isfile(polyaxonfile):
Printer.print_error(
"Please provide a path to a polyaxonfile to create a component version.",
command_help="hub push",
sys_exit=True,
)
try:
plx_file = get_specification(data=polyaxonfile)
except Exception as e:
handle_cli_error(e, message="Polyaxonfile is not valid.")
sys.exit(1)
if not owner or not hub_name or not version:
Printer.print_error(
"Please provide a valid component version with --name=owner/hub-name:version. "
)
sys.exit(1)
polyaxon_client = PolyaxonClient()
try:
polyaxon_client.component_hub_v1.get_component_version(owner, hub_name, version)
to_update = True
except (ApiException, HTTPError):
to_update = False
if to_update:
if not click.confirm(
"A component version {}/{}:{} already exists. "
"Do you want to push force this version?".format(owner, hub_name, version)
):
click.echo("Existing without pushing component version.")
sys.exit(1)
try:
hub_config = V1ComponentVersion(
name=version,
description=description,
tags=tags,
content=plx_file.to_dict(dump=True),
)
if to_update:
_version = polyaxon_client.component_hub_v1.update_component_version(
owner,
hub_name,
version,
hub_config,
)
else:
_version = polyaxon_client.component_hub_v1.create_component_version(
owner,
hub_name,
hub_config,
)
except (ApiException, HTTPError) as e:
handle_cli_error(
e, message="Could not create component version `{}`.".format(hub_name)
)
sys.exit(1)
Printer.print_success(
"Component version `{}` was created successfully.".format(_version.name)
)
click.echo(
"You can view this component version on Polyaxon UI: {}".format(
get_dashboard_url(
subpath="{}/hub/{}/versions/{}".format(owner, hub_name, _version.name)
)
)
)
def run(
ctx,
project,
polyaxonfile,
name,
tags,
description,
upload,
log,
local,
conda_env,
params,
profile,
nocache,
):
"""Run polyaxonfile specification.
Examples:
\b
```bash
$ polyaxon run -f file -f file_override ...
```
Upload before running
\b
```bash
$ polyaxon run -f file -u
```
Run and set description and tags for this run
\b
```bash
$ polyaxon run -f file -u --description="Description of the current run" --tags="foo, bar, moo"
```
Run and set a unique name for this run
\b
```bash
polyaxon run --name=foo
```
Run for a specific project
\b
```bash
$ polyaxon run -p project1 -f file.yaml
```
Run with updated params
\b
```bash
$ polyaxon run -p project1 -f file.yaml -P param1=234.2 -P param2=relu
```
"""
specification = check_polyaxonfile(polyaxonfile,
params=params,
profile=profile,
nocache=nocache,
log=False)
owner, project_name = get_project_or_local(project)
tags = validate_tags(tags)
if local:
try:
run_spec = get_specification(specification.generate_run_data())
run_spec.apply_context()
except PolyaxonSchemaError:
Printer.print_error(
"Could not run this polyaxonfile locally, "
"a context is required to resolve it dependencies.")
sys.exit(1)
if conda_env:
conda_run(
ctx=ctx,
name=name,
owner=owner,
project_name=project_name,
description=description,
tags=tags,
specification=run_spec,
log=log,
conda_env=conda_env,
)
else:
docker_run(
ctx=ctx,
name=name,
owner=owner,
project_name=project_name,
description=description,
tags=tags,
specification=run_spec,
log=log,
)
else:
platform_run(
ctx=ctx,
name=name,
owner=owner,
project_name=project_name,
description=description,
tags=tags,
specification=specification,
upload=upload,
log=log,
can_upload=all([upload, project]),
)
def run(
ctx,
project,
polyaxonfile,
python_module,
url,
hub,
name,
tags,
description,
upload,
log,
watch,
local,
conda_env,
params,
profile,
queue,
nocache,
):
"""Run polyaxonfile specification.
Examples:
\b
$ polyaxon run -f file -f file_override ...
Upload before running
\b
$ polyaxon run -f file -u
Run and set description and tags for this run
\b
$ polyaxon run -f file -u --description="Description of the current run" --tags="foo, bar, moo"
Run and set a unique name for this run
\b
polyaxon run --name=foo
Run for a specific project
\b
$ polyaxon run -p project1 -f file.yaml
Run with updated params
\b
$ polyaxon run -p project1 -f file.yaml -P param1=234.2 -P param2=relu
If a python file contains a component main, you can run that component
\b
polyaxon run -pm path/to/my-component.py
If a python file contains more than one component, you can specify the component to run
\b
polyaxon run -pm path/to/my-component.py:componentA
"""
op_spec = check_polyaxonfile(
polyaxonfile=polyaxonfile,
python_module=python_module,
url=url,
hub=hub,
params=params,
profile=profile,
queue=queue,
nocache=nocache,
log=False,
)
owner, project_name = get_project_or_local(project, is_cli=True)
tags = validate_tags(tags)
if local:
try:
compiled_operation = OperationSpecification.compile_operation(op_spec)
compiled_operation = CompiledOperationSpecification.apply_context(
compiled_operation
)
except (PolyaxonSchemaError, ValidationError):
Printer.print_error(
"Could not run this polyaxonfile locally, "
"a context is required to resolve it dependencies."
)
sys.exit(1)
docker_run(
ctx=ctx,
name=name,
owner=owner,
project_name=project_name,
description=description,
tags=tags,
compiled_operation=compiled_operation,
log=log,
)
elif settings.CLIENT_CONFIG.no_api:
k8s_run(
ctx=ctx,
name=name,
owner=owner,
project_name=project_name,
description=description,
tags=tags,
op_spec=op_spec,
upload=upload,
log=log,
can_upload=all([upload, project]),
)
else:
platform_run(
ctx=ctx,
name=name,
owner=owner,
project_name=project_name,
description=description,
tags=tags,
op_spec=op_spec,
upload=upload,
log=log,
watch=watch,
can_upload=all([upload, project]),
)
def log_tags(self, tags, reset=False):
patch_dict = {"tags": validate_tags(tags)}
if reset is False:
patch_dict["merge"] = True
self._update(patch_dict)
def push(name, description, tags, run_uid):
"""Push a new model version.
If the name corresponds to an existing model version, it will be updated.
Example:
\b
$ polyaxon registry push -f polyaxonfile.yaml --name=kaniko:latest --description="Tool to build container images"
\b
$ polyaxon registry push -f polyaxonfile.yaml --name=owner/name:v1 --description="Model description"
"""
if not name:
Printer.print_error(
"Please provide a name to create a model version.",
command_help="registry push",
sys_exit=True,
)
owner, registry_name, version, is_version = get_info(None, name)
tags = validate_tags(tags)
if not owner or not registry_name or not version:
Printer.print_error(
"Please provide a valid model version with --name=owner/registry-name:version. "
)
sys.exit(1)
polyaxon_client = PolyaxonClient()
try:
polyaxon_client.model_registry_v1.get_model_version(
owner, registry_name, version
)
to_update = True
except (ApiException, HTTPError):
to_update = False
if to_update:
if not click.confirm(
"A model version {}/{}:{} already exists. "
"Do you want to push force this version?".format(
owner, registry_name, version
)
):
click.echo("Existing without pushing model version.")
sys.exit(1)
try:
registry_config = V1ModelVersion(
name=version,
description=description,
tags=tags,
run=run_uid,
)
if to_update:
_version = polyaxon_client.model_registry_v1.update_model_version(
owner,
registry_name,
version,
registry_config,
)
else:
_version = polyaxon_client.model_registry_v1.create_model_version(
owner,
registry_name,
registry_config,
)
except (ApiException, HTTPError) as e:
handle_cli_error(
e, message="Could not create model version `{}`.".format(registry_name)
)
sys.exit(1)
Printer.print_success(
"Model version `{}` was created successfully.".format(_version.name)
)
click.echo(
"You can view this model version on Polyaxon UI: {}".format(
get_dashboard_url(
subpath="{}/registry/{}/versions/{}".format(
owner, registry_name, _version.name
)
)
)
)
def run(
ctx,
project,
polyaxonfile,
python_module,
url,
hub,
name,
tags,
description,
log,
upload,
upload_from,
upload_to,
watch,
local,
params,
presets,
queue,
nocache,
cache,
eager,
git_preset,
git_revision,
ignore_template,
):
"""Run polyaxonfile specification.
Examples:
\b
$ polyaxon run -f file -f file_override ...
Run and set description and tags for this run
\b
$ polyaxon run -f file --description="Description of the current run" --tags="foo, bar, moo"
Run and set a unique name for this run
\b
polyaxon run --name=foo
Run for a specific project
\b
$ polyaxon run -p project1 -f file.yaml
Run with updated params
\b
$ polyaxon run -p project1 -f file.yaml -P param1=234.2 -P param2=relu
If a python file contains a component main, you can run that component
\b
$ polyaxon run -pm path/to/my-component.py
If a python file contains more than one component, you can specify the component to run
\b
$ polyaxon run -pm path/to/my-component.py:componentA
Uploading from everything in the current folder to the default uploads path
\b
$ polyaxon run ... -u
Uploading from everything in the current folder to a custom path, e.g. code
\b
$ polyaxon run ... -u-to code
Uploading from everything from a sub-folder, e.g. ./code to the a custom path, e.g. new-code
\b
$ polyaxon run ... -u-from ./code -u-to new-code
"""
if cache and nocache:
Printer.print_error(
"You can't use `--cache` and `--nocache` at the same.", sys_exit=True
)
if (upload_to or upload_from) and not upload:
upload = True
if upload and eager:
Printer.print_error(
"You can't use `--upload` and `--eager` at the same.", sys_exit=True
)
git_init = None
if git_preset or git_revision:
# Check that the current path was initialized
if not GitConfigManager.is_initialized():
Printer.print_error(
"You can't use `--git-preset [--git-revision]`, "
"the current path is not initialized with a valid git connection or a git url, "
"please run `polyaxon init [--git-connection] [--git-url]` "
"to set a valid git configuration.",
sys_exit=True,
)
git_init = GitConfigManager.get_config()
if git_init.git is None:
GitConfigManager.purge(visibility=GitConfigManager.VISIBILITY_LOCAL)
Printer.print_error(
"Polyaxon could not start a new run with the `[--git-preset] or [--git-revision]`. "
"The current path is initialized with "
"an invalid git connection or an invalid git url.\n"
"please run `polyaxon init [--git-connection] [--git-url]` "
"to properly initialize the current path.",
sys_exit=True,
)
if git_revision:
git_init.git.revision = git_revision
elif code_reference.is_git_initialized(path="."):
if code_reference.is_dirty(path="."):
Printer.print_warning(
"Polyaxon detected uncommitted changes in the current git repo!"
)
commit_hash = code_reference.get_commit()
git_init.git.revision = commit_hash
else:
Printer.print_warning(
"Polyaxon could not find a valid git repo, "
"and will not add the current commit to the git initializer."
)
presets = validate_tags(presets)
op_spec = check_polyaxonfile(
polyaxonfile=polyaxonfile,
python_module=python_module,
url=url,
hub=hub,
params=params,
presets=presets,
queue=queue,
cache=cache,
nocache=nocache,
verbose=False,
eager=eager,
git_init=git_init,
ignore_template=ignore_template,
)
if ignore_template:
op_spec.disable_template()
if op_spec.is_template():
click.echo("Please customize the specification or disable the template.")
sys.exit(1)
owner, project_name = get_project_or_local(project, is_cli=True)
tags = validate_tags(tags)
if local:
try:
compiled_operation = OperationSpecification.compile_operation(op_spec)
compiled_operation = (
CompiledOperationSpecification.apply_operation_contexts(
compiled_operation
)
)
except (PolyaxonSchemaError, ValidationError):
Printer.print_error(
"Could not run this polyaxonfile locally, "
"a context is required to resolve it dependencies."
)
sys.exit(1)
docker_run(
ctx=ctx,
name=name,
owner=owner,
project_name=project_name,
description=description,
tags=tags,
compiled_operation=compiled_operation,
log=log,
)
elif settings.CLIENT_CONFIG.no_api:
k8s_run(
ctx=ctx,
name=name,
owner=owner,
project_name=project_name,
description=description,
tags=tags,
op_spec=op_spec,
log=log,
)
else:
platform_run(
ctx=ctx,
name=name,
owner=owner,
project_name=project_name,
description=description,
tags=tags,
op_spec=op_spec,
log=log,
upload=upload,
upload_to=upload_to,
upload_from=upload_from,
watch=watch,
eager=eager,
)
def ls(ctx, io, query, sort, limit, offset, columns):
"""List runs for this project.
Uses /docs/core/cli/#caching
Examples:
Get all runs:
\b
Get all runs 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
$ polyaxon ops ls \
-q "status:created|running, started_at:2018-01-01..2018-01-02, \
params.activation:sigmoid, metrics.loss:<=0.2"
Get all runs sorted by update date:
\b
$ polyaxon ops ls -s "-updated_at"
Get all runs of kind job:
\b
$ polyaxon ops ls -q "kind: job"
Get all runs of kind service:
\b
$ polyaxon ops ls -q "kind: service"
"""
owner, project_name = get_project_or_local(ctx.obj.get("project"), is_cli=True)
try:
polyaxon_client = RunClient(owner=owner, project=project_name)
response = polyaxon_client.list(
limit=limit, offset=offset, query=query, sort=sort
)
except (ApiException, HTTPError) as e:
handle_cli_error(
e, message="Could not get runs for project `{}`.".format(project_name)
)
sys.exit(1)
meta = get_meta_response(response)
if meta:
Printer.print_header("Runs for project `{}/{}`.".format(owner, project_name))
Printer.print_header("Navigation:")
dict_tabulate(meta)
else:
Printer.print_header(
"No runs found for project `{}/{}`.".format(owner, project_name)
)
objects = [Printer.add_status_color(o.to_dict()) for o in response.results]
if io:
objects = get_runs_with_keys(objects=objects, params_keys=["inputs", "outputs"])
objects = list_dicts_to_tabulate(
objects,
include_attrs=validate_tags(columns),
exclude_attrs=[
"owner",
"project",
"description",
"content",
"raw_content",
"deleted",
"readme",
"settings",
"meta_info",
"original",
"pipeline",
"role",
"status_conditions",
"is_helper",
],
)
else:
objects = list_dicts_to_tabulate(
objects,
include_attrs=validate_tags(columns),
exclude_attrs=[
"owner",
"project",
"description",
"content",
"raw_content",
"deleted",
"readme",
"inputs",
"outputs",
"settings",
"meta_info",
"original",
"pipeline",
"role",
"status_conditions",
"is_helper",
],
)
if objects:
Printer.print_header("Runs:")
objects.pop("project_name", None)
dict_tabulate(objects, is_list_dict=True)
def ls(ctx, project, io, to_csv, query, sort, limit, offset, columns, offline,
offline_path):
"""List runs for this project.
Uses /docs/core/cli/#caching
Examples:
Get all runs:
\b
Get all runs 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
$ polyaxon ops ls \
-q "status:created|running, started_at:2018-01-01..2018-01-02, \
params.activation:sigmoid, metrics.loss:<=0.2"
Get all runs sorted by update date:
\b
$ polyaxon ops ls -s "-updated_at"
Get all runs of kind job:
\b
$ polyaxon ops ls -q "kind: job"
Get all runs of kind service:
\b
$ polyaxon ops ls -q "kind: service"
"""
if offline:
offline_path = offline_path or container_contexts.CONTEXT_OFFLINE_ROOT
offline_path_format = "{}/{{}}/run_data.json".format(offline_path)
if not os.path.exists(offline_path) or not os.path.isdir(offline_path):
Printer.print_error(
f"Could not list offline runs, the path `{offline_path}` "
f"does not exist or is not a directory.")
sys.exit(1)
results = []
for uid in os.listdir(offline_path):
run_path = offline_path_format.format(uid)
if os.path.exists(run_path):
results.append(RunConfigManager.read_from_path(run_path))
else:
Printer.print_warning(
f"Skipping run {uid}, offline data not found.")
else:
owner, project_name = get_project_or_local(project
or ctx.obj.get("project"),
is_cli=True)
try:
polyaxon_client = RunClient(owner=owner, project=project_name)
response = polyaxon_client.list(limit=limit,
offset=offset,
query=query,
sort=sort)
except (ApiException, HTTPError) as e:
handle_cli_error(
e,
message="Could not get runs for project `{}`.".format(
project_name))
sys.exit(1)
meta = get_meta_response(response)
if meta:
Printer.print_header("Runs for project `{}/{}`.".format(
owner, project_name))
Printer.print_header("Navigation:")
dict_tabulate(meta)
else:
Printer.print_header("No runs found for project `{}/{}`.".format(
owner, project_name))
results = response.results
objects = [Printer.add_status_color(o.to_dict()) for o in results]
columns = validate_tags(columns)
if io:
objects, prefixed_columns = flatten_keys(
objects=objects,
columns=["inputs", "outputs"],
columns_prefix={
"inputs": "in",
"outputs": "out"
},
)
if columns:
columns = {prefixed_columns.get(col, col) for col in columns}
if to_csv:
objects = list_dicts_to_csv(
objects,
include_attrs=columns,
exclude_attrs=DEFAULT_EXCLUDE,
)
else:
objects = list_dicts_to_tabulate(
objects,
include_attrs=columns,
exclude_attrs=DEFAULT_EXCLUDE,
humanize_values=True,
upper_keys=True,
)
else:
if to_csv:
objects = list_dicts_to_csv(
objects,
include_attrs=columns,
exclude_attrs=DEFAULT_EXCLUDE + ["inputs", "outputs"],
)
else:
objects = list_dicts_to_tabulate(
objects,
include_attrs=columns,
exclude_attrs=DEFAULT_EXCLUDE + ["inputs", "outputs"],
humanize_values=True,
upper_keys=True,
)
if objects:
if to_csv:
filename = "./results.csv"
write_csv(objects, filename=filename)
Printer.print_success("CSV file generated: `{}`".format(filename))
else:
Printer.print_header("Runs:")
objects.pop("project_name", None)
dict_tabulate(objects, is_list_dict=True)
def test_validate_tags(self):
assert ["foo", "bar"] == validate_tags("foo,bar")
assert ["foo", "bar"] == validate_tags(" , foo, bar, ")
assert ["foo", "bar"] == validate_tags(["foo", "bar"])
assert ["foo", "bar"] == validate_tags(["foo", "bar", 1, 2])
assert [] == validate_tags([{}, {}, 1, 2])
def ls(ctx, io, to_csv, query, sort, limit, offset, columns):
"""List runs for this project.
Uses /docs/core/cli/#caching
Examples:
Get all runs:
\b
Get all runs 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
$ polyaxon ops ls \
-q "status:created|running, started_at:2018-01-01..2018-01-02, \
params.activation:sigmoid, metrics.loss:<=0.2"
Get all runs sorted by update date:
\b
$ polyaxon ops ls -s "-updated_at"
Get all runs of kind job:
\b
$ polyaxon ops ls -q "kind: job"
Get all runs of kind service:
\b
$ polyaxon ops ls -q "kind: service"
"""
owner, project_name = get_project_or_local(ctx.obj.get("project"),
is_cli=True)
try:
polyaxon_client = RunClient(owner=owner, project=project_name)
response = polyaxon_client.list(limit=limit,
offset=offset,
query=query,
sort=sort)
except (ApiException, HTTPError) as e:
handle_cli_error(e,
message="Could not get runs for project `{}`.".format(
project_name))
sys.exit(1)
meta = get_meta_response(response)
if meta:
Printer.print_header("Runs for project `{}/{}`.".format(
owner, project_name))
Printer.print_header("Navigation:")
dict_tabulate(meta)
else:
Printer.print_header("No runs found for project `{}/{}`.".format(
owner, project_name))
objects = [Printer.add_status_color(o.to_dict()) for o in response.results]
columns = validate_tags(columns)
if io:
objects, prefixed_columns = flatten_keys(
objects=objects,
columns=["inputs", "outputs"],
columns_prefix={
"inputs": "in",
"outputs": "out"
},
)
if columns:
columns = {prefixed_columns.get(col, col) for col in columns}
if to_csv:
objects = list_dicts_to_csv(
objects,
include_attrs=columns,
exclude_attrs=DEFAULT_EXCLUDE,
)
else:
objects = list_dicts_to_tabulate(
objects,
include_attrs=columns,
exclude_attrs=DEFAULT_EXCLUDE,
humanize_values=True,
upper_keys=True,
)
else:
if to_csv:
objects = list_dicts_to_csv(
objects,
include_attrs=columns,
exclude_attrs=DEFAULT_EXCLUDE,
)
else:
objects = list_dicts_to_tabulate(
objects,
include_attrs=columns,
exclude_attrs=DEFAULT_EXCLUDE,
humanize_values=True,
upper_keys=True,
)
if objects:
if to_csv:
write_csv(objects)
else:
Printer.print_header("Runs:")
objects.pop("project_name", None)
dict_tabulate(objects, is_list_dict=True)
