def experiments(ctx, page, metrics): """List experiments for this experiment group Uses [Caching](/polyaxon_cli/introduction#Caching) """ user, project_name, _group = get_group_or_local(ctx.obj['project'], ctx.obj['group']) 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)) if metrics: objects = get_experiments_with_metrics(response) else: objects = [Printer.add_status_color(o.to_light_dict(humanize_values=True)) for o in response['results']] objects = list_dicts_to_tabulate(objects) if objects: Printer.print_header("Experiments:") objects.pop('experiment_group', None) objects.pop('experiment_group_name', None) objects.pop('project_name', None) dict_tabulate(objects, is_list_dict=True)
def get_experiment_job_statuses(): try: response = PolyaxonClient().experiment_job.get_statuses( user, project_name, _experiment, _job, page=page) except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) 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([ Printer.add_status_color(o.to_light_dict(humanize_values=True), status_key='status') for o in response['results'] ]) if objects: Printer.print_header("Statuses:") objects.pop('job', None) dict_tabulate(objects, is_list_dict=True)
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 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 get(project): """Get info for current project, by project_name, or user/project_name. Examples: To get current project: ``` polyaxon project get ``` To get a project by uuid ``` polyaxon project get user/project ``` """ user, project_name = get_project_or_local(project) try: response = PolyaxonClients().project.get_project(user, project_name) except (PolyaxonHTTPError, PolyaxonShouldExitError) as e: Printer.print_error('Could not get project `{}`.'.format(project)) Printer.print_error('Error message `{}`.'.format(e)) sys.exit(1) response = response.to_dict() Printer.print_header("Project info:") dict_tabulate(response)
def list(page): """List projects.""" user = AuthConfigManager.get_value('username') if not user: Printer.print_error('Please login first. `polyaxon login --help`') page = page or 1 try: response = PolyaxonClients().project.list_projects(user, page=page) except (PolyaxonHTTPError, PolyaxonShouldExitError) as e: Printer.print_error('Could not get list of projects.') Printer.print_error('Error message `{}`.'.format(e)) sys.exit(1) meta = get_meta_response(response) if meta: Printer.print_header('Projects for current user') Printer.print_header('Navigation:') dict_tabulate(meta) else: Printer.print_header('No projects found for current user') objects = list_dicts_to_tabulate( [o.to_dict() for o in response['results']]) if objects: Printer.print_header("Projects:") dict_tabulate(objects, is_list_dict=True)
def list(page): # pylint:disable=redefined-builtin """List projects. Uses [Caching](/references/polyaxon-cli/#caching) """ user = AuthConfigManager.get_value('username') if not user: Printer.print_error('Please login first. `polyaxon login --help`') page = page or 1 try: response = PolyaxonClient().project.list_projects(user, page=page) except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e: Printer.print_error('Could not get list of projects.') Printer.print_error('Error message `{}`.'.format(e)) sys.exit(1) meta = get_meta_response(response) if meta: Printer.print_header('Projects for current user') Printer.print_header('Navigation:') dict_tabulate(meta) else: Printer.print_header('No projects found for current user') objects = list_dicts_to_tabulate( [o.to_light_dict( humanize_values=True, exclude_attrs=['uuid', 'experiment_groups', 'experiments', 'description', 'num_experiments', 'num_independent_experiments', 'num_experiment_groups', 'num_jobs', 'num_builds', 'unique_name']) for o in response['results']]) if objects: Printer.print_header("Projects:") dict_tabulate(objects, is_list_dict=True)
def tensorboards(ctx, query, sort, page): """List tensorboard jobs for this project. Uses [Caching](/references/polyaxon-cli/#caching) """ user, project_name = get_project_or_local(ctx.obj.get('project')) page = page or 1 try: response = PolyaxonClient().project.list_tensorboards(username=user, project_name=project_name, query=query, sort=sort, page=page) except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e: Printer.print_error('Could not get tensorboards for project `{}`.'.format(project_name)) Printer.print_error('Error message `{}`.'.format(e)) sys.exit(1) meta = get_meta_response(response) if meta: Printer.print_header('Tensorboards for project `{}/{}`.'.format(user, project_name)) Printer.print_header('Navigation:') dict_tabulate(meta) else: Printer.print_header('No tensorboards found for project `{}/{}`.'.format(user, project_name)) objects = [Printer.add_status_color(o.to_light_dict(humanize_values=True)) for o in response['results']] objects = list_dicts_to_tabulate(objects) if objects: Printer.print_header("Tensorboards:") objects.pop('project_name', None) 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 version(cli, platform): """Print the current version of the cli and platform.""" version_client = PolyaxonClient().version cli = cli or not any([cli, platform]) if cli: try: server_version = version_client.get_cli_version() except AuthorizationError: session_expired() sys.exit(1) except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e: Printer.print_error('Could not get cli version.') Printer.print_error('Error message `{}`.'.format(e)) sys.exit(1) cli_version = get_current_version() Printer.print_header('Current cli version: {}.'.format(cli_version)) Printer.print_header('Supported cli versions:') dict_tabulate(server_version.to_dict()) if platform: try: platform_version = version_client.get_platform_version() except AuthorizationError: session_expired() sys.exit(1) except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e: Printer.print_error('Could not get platform version.') Printer.print_error('Error message `{}`.'.format(e)) sys.exit(1) chart_version = version_client.get_chart_version() Printer.print_header('Current platform version: {}.'.format(chart_version.version)) Printer.print_header('Supported platform versions:') dict_tabulate(platform_version.to_dict())
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 get_group_details(group): # pylint:disable=redefined-outer-name if group.description: Printer.print_header("Experiment group description:") click.echo('{}\n'.format(group.description)) response = group.to_light_dict( humanize_values=True, exclude_attrs=['uuid', 'content', 'project', 'experiments', 'description']) Printer.print_header("Experiment group info:") dict_tabulate(response)
def get_project_details(_project): if _project.description: Printer.print_header("Project description:") click.echo('{}\n'.format(_project.description)) response = _project.to_light_dict( humanize_values=True, exclude_attrs=['uuid', 'experiment_groups', 'experiments', 'description']) Printer.print_header("Project info:") dict_tabulate(response)
def get_group_experiments_info(search_algorithm, concurrency, early_stopping=False, **kwargs): info = OrderedDict() info['Search algorithm'] = search_algorithm.lower() info['Concurrency'] = ('{} runs'.format('sequential') if concurrency == 1 else '{} concurrent runs'.format(concurrency)) info['Early stopping'] = 'activated' if early_stopping else 'deactivated' if 'n_experiments' in kwargs: info['Experiments to create'] = kwargs['n_experiments'] dict_tabulate(info)
def get_cluster_info(cluster_config): Printer.print_header("Cluster info:") cluster_dict = cluster_config.to_dict() cluster_info = cluster_dict['version_api'] dict_tabulate(cluster_info) nodes = list_dicts_to_tabulate(cluster_dict['nodes']) if nodes: Printer.print_header("Cluster Nodes:") dict_tabulate(nodes, is_list_dict=True)
def experiments(ctx, metrics, declarations, query, sort, page): """List experiments for this experiment group Uses [Caching](/references/polyaxon-cli/#caching) """ user, project_name, _group = get_project_group_or_local( ctx.obj.get('project'), ctx.obj.get('group')) page = page or 1 try: response = PolyaxonClient().experiment_group.list_experiments( username=user, project_name=project_name, group_id=_group, metrics=metrics, declarations=declarations, query=query, sort=sort, page=page) except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) 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)) if metrics: objects = get_experiments_with_metrics(response) elif declarations: objects = get_experiments_with_declarations(response) else: objects = [ Printer.add_status_color(o.to_light_dict(humanize_values=True)) for o in response['results'] ] objects = list_dicts_to_tabulate(objects) if objects: Printer.print_header("Experiments:") objects.pop('experiment_group', None) objects.pop('experiment_group_name', None) objects.pop('project_name', None) dict_tabulate(objects, is_list_dict=True)
def get_cluster_info(cluster_config): Printer.print_header("Cluster info:") cluster_dict = cluster_config.to_light_dict() cluster_info = cluster_dict['version_api'] dict_tabulate(cluster_info) nodes = list_dicts_to_tabulate([Printer.add_memory_unit(node.to_light_dict(), 'memory') for node in cluster_config.nodes]) if nodes: Printer.print_header("Cluster Nodes:") nodes.pop('status', None) nodes.pop('kernel_version', None) dict_tabulate(nodes, is_list_dict=True)
def groups(ctx, page): """List bookmarked experiment groups for user. Uses [Caching](/references/polyaxon-cli/#caching) Examples: \b ```bash $ polyaxon bookmark groups ``` \b ```bash $ polyaxon bookmark -u adam groups ``` """ user = get_username_or_local(ctx.obj.get('username')) page = page or 1 try: response = PolyaxonClient().bookmark.groups(username=user, page=page) except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e: Printer.print_error( 'Could not get bookmarked experiment groups for user `{}`.'.format( user)) Printer.print_error('Error message `{}`.'.format(e)) sys.exit(1) meta = get_meta_response(response) if meta: Printer.print_header( 'Bookmarked experiment groups for user `{}`.'.format(user)) Printer.print_header('Navigation:') dict_tabulate(meta) else: Printer.print_header( 'No bookmarked experiment groups found for user `{}`.'.format( user)) objects = [ Printer.add_status_color(o.to_light_dict(humanize_values=True)) for o in response['results'] ] objects = list_dicts_to_tabulate(objects) if objects: Printer.print_header("Experiment groups:") dict_tabulate(objects, is_list_dict=True)
def get_node_info(node_config): if not node_config: Printer.print_error('No node was found.') sys.exit(1) node = node_config.to_dict() node.pop('gpus') Printer.print_header("Node info:") dict_tabulate(Printer.add_memory_unit(node, 'memory')) gpus_items = list_dicts_to_tabulate([Printer.add_memory_unit(gpu.to_light_dict(), 'memory') for gpu in node_config.gpus]) if gpus_items: Printer.print_header("Node GPUs:") dict_tabulate(gpus_items, is_list_dict=True)
def get_node_info(node_config): if not node_config: Printer.print_error('No node was found.') sys.exit(1) node = node_config.to_dict() gpus = node.pop('gpus', []) Printer.print_header("Node info:") dict_tabulate(node) gpus_items = list_dicts_to_tabulate(gpus) if gpus_items: Printer.print_header("Node GPUs:") gpus_items.pop('cluster_node') dict_tabulate(gpus_items, is_list_dict=True)
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 get_build_details(_build): if _build.description: Printer.print_header("Build description:") click.echo('{}\n'.format(_build.description)) if _build.resources: get_resources(_build.resources.to_dict(), header="Build resources:") response = _build.to_light_dict( humanize_values=True, exclude_attrs=[ 'uuid', 'content', 'project', 'description', 'resources', 'is_clone', 'build_job' ]) Printer.print_header("Build info:") dict_tabulate(Printer.add_status_color(response))
def statuses(ctx, page): """Get experiment group statuses. Uses [Caching](/references/polyaxon-cli/#caching) Examples: \b ```bash $ polyaxon group -g 2 statuses ``` """ user, project_name, _group = get_project_group_or_local( ctx.obj.get('project'), ctx.obj.get('group')) page = page or 1 try: response = PolyaxonClient().experiment_group.get_statuses(user, project_name, _group, page=page) except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e: Printer.print_error( 'Could not get status for group `{}`.'.format(_group)) Printer.print_error('Error message `{}`.'.format(e)) sys.exit(1) meta = get_meta_response(response) if meta: Printer.print_header('Statuses for group `{}`.'.format(_group)) Printer.print_header('Navigation:') dict_tabulate(meta) else: Printer.print_header( 'No statuses found for group `{}`.'.format(_group)) objects = list_dicts_to_tabulate([ Printer.add_status_color(o.to_light_dict(humanize_values=True), status_key='status') for o in response['results'] ]) if objects: Printer.print_header("Statuses:") objects.pop('experiment_group', None) dict_tabulate(objects, is_list_dict=True)
def jobs(ctx, page): """List jobs for experiment. Uses [Caching](/references/polyaxon-cli/#caching) Examples: \b ```bash $ polyaxon experiment --experiment=1 jobs ``` """ user, project_name, _experiment = get_project_experiment_or_local( ctx.obj.get('project'), ctx.obj.get('experiment')) page = page or 1 try: response = PolyaxonClient().experiment.list_jobs(user, project_name, _experiment, page=page) except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e: Printer.print_error( 'Could not get jobs for experiment `{}`.'.format(_experiment)) Printer.print_error('Error message `{}`.'.format(e)) sys.exit(1) meta = get_meta_response(response) if meta: Printer.print_header('Jobs for experiment `{}`.'.format(_experiment)) Printer.print_header('Navigation:') dict_tabulate(meta) else: Printer.print_header( 'No jobs found for experiment `{}`.'.format(_experiment)) objects = [ Printer.add_status_color(o.to_light_dict(humanize_values=True)) for o in response['results'] ] objects = list_dicts_to_tabulate(objects) if objects: Printer.print_header("Jobs:") objects.pop('experiment', None) dict_tabulate(objects, is_list_dict=True)
def statuses(ctx, page): """Get build job statuses. Uses [Caching](/polyaxon_cli/introduction#Caching) Examples: \b ```bash $ polyaxon build -b 2 statuses ``` """ user, project_name, _build = get_build_or_local(ctx.obj.get('project'), ctx.obj.get('build')) page = page or 1 try: response = PolyaxonClient().build_job.get_statuses(user, project_name, _build, page=page) except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e: Printer.print_error( 'Could not get status for build job `{}`.'.format(_build)) Printer.print_error('Error message `{}`.'.format(e)) sys.exit(1) meta = get_meta_response(response) if meta: Printer.print_header('Statuses for build job `{}`.'.format(_build)) Printer.print_header('Navigation:') dict_tabulate(meta) else: Printer.print_header( 'No statuses found for build job `{}`.'.format(_build)) objects = list_dicts_to_tabulate([ Printer.add_status_color(o.to_light_dict(humanize_values=True), status_key='status') for o in response['results'] ]) if objects: Printer.print_header("Statuses:") objects.pop('job', None) dict_tabulate(objects, is_list_dict=True)
def run(file, description): """Command for running polyaxonfile specification. Example: ``` polyaxon run -f file -f file_override ... ``` """ file = file or 'polyaxonfile.yml' plx_file = check_polyaxonfile(file) num_experiments, concurrency = plx_file.experiments_def project = get_current_project_or_exit() project_client = PolyaxonClients().project if num_experiments == 1: click.echo('Creating an independent experiment.') experiment = ExperimentConfig( description=description, content=plx_file._data, config=plx_file.experiment_specs[0].parsed_data) try: response = project_client.create_experiment( project.user, project.name, experiment) except (PolyaxonHTTPError, PolyaxonShouldExitError) as e: Printer.print_error('Could not create experiment.') Printer.print_error('Error message `{}`.'.format(e)) sys.exit(1) Printer.print_success('Experiment was created') else: click.echo('Creating an experiment group with {} experiments.'.format( num_experiments)) experiment_group = ExperimentGroupConfig(description=description, content=plx_file._data) try: response = project_client.create_experiment_group( project.user, project.name, experiment_group) Printer.print_success('Experiment group was created') except (PolyaxonHTTPError, PolyaxonShouldExitError) as e: Printer.print_error('Could not create experiment group.') Printer.print_error('Error message `{}`.'.format(e)) sys.exit(1) response = response.to_dict() dict_tabulate(response)
def get_job_details(_job): if _job.description: Printer.print_header("Job description:") click.echo('{}\n'.format(_job.description)) if _job.resources: get_resources(_job.resources.to_dict(), header="Job resources:") response = _job.to_light_dict(humanize_values=True, exclude_attrs=[ 'uuid', 'content', 'project', 'description', 'resources', ]) Printer.print_header("Job info:") dict_tabulate(Printer.add_status_color(response))
def statuses(ctx, page): """Get experiment status. Uses [Caching](/polyaxon_cli/introduction#Caching) Example: \b ```bash $ polyaxon experiment statuses 3 ``` \b ```bash $ polyaxon experiment -xp 1 statuses ``` """ user, project_name, _experiment = get_experiment_or_local(ctx.obj['project'], ctx.obj['experiment']) 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([Printer.handle_statuses(o.to_light_dict(humanize_values=True)) for o in response['results']]) if objects: Printer.print_header("Statuses:") objects.pop('experiment', None) dict_tabulate(objects, is_list_dict=True)
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 get(ctx): """Get job. Uses [Caching](/polyaxon_cli/introduction#Caching) Examples: \b ```bash $ polyaxon job --job=1 --experiment=1 get ``` \b ```bash $ polyaxon job --job=1 --project=project_name get ``` """ user, project_name, experiment, _job = get_job_or_local( ctx.obj['project'], ctx.obj['experiment'], ctx.obj['job']) try: response = PolyaxonClients().job.get_job(user, project_name, experiment, _job) # Set caching only if we have an initialized project if ProjectManager.is_initialized(): JobManager.set_config(response) except (PolyaxonHTTPError, PolyaxonShouldExitError) as e: Printer.print_error('Could not get job `{}`.'.format(_job)) Printer.print_error('Error message `{}`.'.format(e)) sys.exit(1) if response.resources: get_resources(response.resources.to_dict(), header="Job resources:") response = Printer.add_status_color( response.to_light_dict(humanize_values=True, exclude_attrs=[ 'uuid', 'definition', 'experiment', 'unique_name', 'resources' ])) Printer.print_header("Job info:") dict_tabulate(response)