def delete(ctx): """Delete project. Uses [Caching](/references/polyaxon-cli/#caching) """ owner, project_name = get_project_or_local(ctx.obj.get("project")) 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 = PolyaxonClient() response = polyaxon_client.projects_v1.delete_project( owner, project_name) 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 get(ctx): """Get info for current project, by project_name, or user/project_name. Uses [Caching](/references/polyaxon-cli/#caching) Examples: To get current project: \b ```bash $ polyaxon project get ``` To get a project by name \b ```bash $ polyaxon project get user/project ``` """ owner, project_name = get_project_or_local(ctx.obj.get("project")) try: polyaxon_client = PolyaxonClient() response = polyaxon_client.projects_v1.get_project(owner, project_name) except (ApiException, HTTPError) as e: handle_cli_error( e, message="Could not get project `{}`.".format(project_name)) sys.exit(1) get_project_details(response)
def ci(ctx, enable, disable): # pylint:disable=assign-to-new-keyword """Enable/Disable CI on this project. Uses [Caching](/references/polyaxon-cli/#caching) Example: \b ```bash $ polyaxon project ci --enable ``` \b ```bash $ polyaxon project ci --disable ``` """ owner, project_name = get_project_or_local(ctx.obj.get("project")) polyaxon_client = PolyaxonClient() def enable_ci(): try: polyaxon_client.projects_v1.enable_ci(owner, project_name) except (ApiException, HTTPError) as e: handle_cli_error( e, message="Could not enable CI on project `{}`.".format( project_name)) sys.exit(1) Printer.print_success( "Polyaxon CI was successfully enabled on project: `{}`.".format( project_name)) def disable_ci(): try: polyaxon_client.projects_v1.disable_ci(owner, project_name) except (ApiException, HTTPError) as e: handle_cli_error( e, message="Could not disable CI on project `{}`.".format( project_name)) sys.exit(1) Printer.print_success( "Polyaxon CI was successfully disabled on project: `{}`.".format( project_name)) if enable: enable_ci() if disable: disable_ci()
def update(ctx, name, description, private): """Update project. Uses [Caching](/references/polyaxon-cli/#caching) Example: \b ```bash $ polyaxon update foobar --description="Image Classification with DL using TensorFlow" ``` \b ```bash $ polyaxon update mike1/foobar --description="Image Classification with DL using TensorFlow" ``` \b ```bash $ polyaxon update --tags="foo, bar" ``` """ owner, project_name = get_project_or_local(ctx.obj.get("project")) update_dict = {} if name: update_dict["name"] = name if description: update_dict["description"] = description 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 = PolyaxonClient() response = polyaxon_client.projects_v1.patch_project( owner, project_name, 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_project_details(response)
def download(ctx, commit): """Download code of the current project.""" user, project_name = get_project_or_local(ctx.obj.get("project")) try: polyaxon_client = PolyaxonClient() polyaxon_client.projects_v1.download_repo(user, project_name, commit=commit) except (ApiException, HTTPError) as e: handle_cli_error( e, message="Could not download code for project `{}`.".format( project_name)) sys.exit(1) Printer.print_success("Files downloaded.")
def bookmark(ctx): """Bookmark project. Uses [Caching](/references/polyaxon-cli/#caching) """ owner, project_name = get_project_or_local(ctx.obj.get("project")) try: polyaxon_client = PolyaxonClient() polyaxon_client.projects_v1.bookmark_project(owner, project_name) except (ApiException, HTTPError) as e: handle_cli_error(e, message="Could not bookmark project `{}/{}`.".format( owner, project_name)) sys.exit(1) Printer.print_success("Project `{}/{}` is bookmarked.".format( owner, project_name))
def init(project, polyaxonfile, purge): """Initialize a new polyaxonfile specification.""" owner, project_name = get_project_or_local(project) try: polyaxon_client = PolyaxonClient() project_config = polyaxon_client.projects_v1.get_project( owner, project_name) except (ApiException, HTTPError) as e: Printer.print_error( "Make sure you have a project with this name `{}`".format(project)) handle_cli_error( e, message="You can a create new project with this command: " "polyaxon project create " "--name={} [--description=...] [--tags=...]".format(project_name), ) sys.exit(1) if purge: ProjectManager.purge() IgnoreManager.purge() init_project = False if ProjectManager.is_initialized(): local_project = ProjectManager.get_config() click.echo( "Warning! This project is already initialized with the following project:" ) with indentation.indent(4): indentation.puts("User: {}".format(local_project.user)) indentation.puts("Project: {}".format(local_project.name)) if click.confirm("Would you like to override this current config?", default=False): init_project = True else: init_project = True if init_project: ProjectManager.purge() config = polyaxon_client.api_client.sanitize_for_serialization( project_config) ProjectManager.set_config(config, init=True) Printer.print_success("Project was initialized") else: Printer.print_header("Project config was not changed.") init_ignore = False if IgnoreManager.is_initialized(): click.echo("Warning! Found a .polyaxonignore file.") if click.confirm("Would you like to override it?", default=False): init_ignore = True else: init_ignore = True if init_ignore: IgnoreManager.init_config() Printer.print_success("New .polyaxonignore file was created.") else: Printer.print_header(".polyaxonignore file was not changed.") if polyaxonfile: create_polyaxonfile() create_debug_polyaxonfile()
def get_project_run_or_local(project=None, run_uuid=None): user, project_name = get_project_or_local(project) run_uuid = get_run_or_local(run_uuid) return user, project_name, run_uuid
def ls(ctx, io, query, sort, limit, offset): """List runs for this project. Uses [Caching](/references/polyaxon-cli/#caching) Examples: Get all runs: \b ```bash $ polyaxon project runs ``` 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 ```bash $ polyaxon project runs \ -q "status:created|running, started_at:2018-01-01..2018-01-02, \ params.activation:sigmoid, metric.loss:<=0.2" ``` Get all runs sorted by update date \b ```bash $ polyaxon project runs -s "-updated_at" ``` """ owner, project_name = get_project_or_local(ctx.obj.get("project")) try: polyaxon_client = PolyaxonClient() params = get_query_params(limit=limit, offset=offset, query=query, sort=sort) response = polyaxon_client.runs_v1.list_runs(owner=owner, project=project_name, **params) 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("Experiments 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, exclude_attrs=[ "owner", "project", "description", "content", "deleted", "readme", "run_env", ], ) else: objects = list_dicts_to_tabulate( objects, exclude_attrs=[ "owner", "project", "description", "content", "deleted", "readme", "run_env", "inputs", "outputs", ], ) if objects: Printer.print_header("Runs:") objects.pop("project_name", None) dict_tabulate(objects, is_list_dict=True)
def git(ctx, url, private, sync): # pylint:disable=assign-to-new-keyword """Set/Sync git repo on this project. TODO Uses [Caching](/references/polyaxon-cli/#caching) Example: \b ```bash $ polyaxon project git --url=https://github.com/polyaxon/polyaxon-quick-start ``` \b ```bash $ polyaxon project git --url=https://github.com/polyaxon/polyaxon-quick-start --private ``` """ user, project_name = get_project_or_local(ctx.obj.get("project")) def git_set_url(): if private: click.echo( '\nSetting a private git repo "{}" on project: {} ...\n'. format(url, project_name)) else: click.echo( '\nSetting a public git repo "{}" on project: {} ...\n'.format( url, project_name)) try: PolyaxonClient().projects_v1.set_repo(user, project_name, url, not private) except (ApiException, HTTPError) as e: handle_cli_error( e, message="Could not set git repo on project `{}`.".format( project_name), ) sys.exit(1) Printer.print_success( "Project was successfully initialized with `{}`.".format(url)) def git_sync_repo(): try: response = PolyaxonClient().projects_v1.sync_repo( user, project_name) except (ApiException, HTTPError) as e: handle_cli_error( e, message="Could not sync git repo on project `{}`.".format( project_name), ) sys.exit(1) click.echo(response.status_code) Printer.print_success( "Project was successfully synced with latest changes.") if url: git_set_url() if sync: git_sync_repo()
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]), )