def show_ranking(ctx, workflow, all): """Show ranking for workflow results.""" workflow_id = ctx.obj.get_workflow(ctx.params) with service() as api: doc = api.workflows().get_ranking(workflow_id=workflow_id, include_all=all) # Print ranking. headline = ['Rank', 'Name'] types = [PARA_INT, PARA_STRING] mapping = dict() for col in doc[labels.WORKFLOW_SCHEMA]: headline.append(col[labels.COLUMN_TITLE]) types.append(col[labels.COLUMN_TYPE]) mapping[col[labels.COLUMN_NAME]] = len(mapping) table = ResultTable(headline=headline, types=types) rank = 1 for run in doc[labels.RANKING]: group = run[labels.WORKFLOW_GROUP][labels.GROUP_NAME] row = [rank, group] + ([None] * (len(headline) - 2)) for r in run[labels.RUN_RESULTS]: row[mapping[r[labels.COLUMN_NAME]] + 2] = r[labels.COLUMN_VALUE] table.add(row) rank += 1 for line in table.format(): click.echo(line)
def show_run(run): """Show workflow run information.""" with service() as api: doc = api.runs().get_run(run_id=run) click.echo('ID: {}'.format(doc[labels.RUN_ID])) if labels.RUN_STARTED in doc: click.echo('Started at: {}'.format(doc[labels.RUN_STARTED][:19])) if labels.RUN_FINISHED in doc: click.echo('Finished at: {}'.format(doc[labels.RUN_FINISHED][:19])) click.echo('State: {}'.format(doc[labels.RUN_STATE])) # Get index of parameters. The index contains the parameter name # and type parameters = ParameterIndex.from_dict(doc[labels.RUN_PARAMETERS]) click.echo('\nArguments:') for arg in doc['arguments']: para = parameters[arg['name']] if para.is_file(): file_id, target_path = deserialize_fh(arg['value']) value = '{} ({})'.format(file_id, target_path) else: value = arg['value'] click.echo(' {} = {}'.format(para.name, value)) if labels.RUN_ERRORS in doc: click.echo('\nMessages:') for msg in doc[labels.RUN_ERRORS]: click.echo(' {}'.format(msg)) elif labels.RUN_FILES in doc: click.echo('\nFiles:') for res in doc[labels.RUN_FILES]: click.echo(' {} ({})'.format(res[flbls.FILE_ID], res[flbls.FILE_NAME]))
def download_file(ctx, group, file, output): """Download a previously uploaded file.""" group_id = ctx.obj.get_group(ctx.params) with service() as api: buf = api.uploads().get_uploaded_file(group_id=group_id, file_id=file) with open(output, 'wb') as local_file: local_file.write(buf.read())
def start_run(ctx, group, configfile): """Start new workflow run.""" group_id = ctx.obj.get_group(ctx.params) config = factory.read_config(configfile) if configfile else None with service() as api: doc = api.groups().get_group(group_id=group_id) config = config if config else doc[glbls.ENGINE_CONFIG] # Create list of file descriptors for uploaded files that are included # in the submission handle files = [] for fh in doc[glbls.GROUP_UPLOADS]: files.append(( fh[flbls.FILE_ID], fh[flbls.FILE_NAME], fh[flbls.FILE_DATE][:19]) ) # Create list of additional user-provided template parameters parameters = ParameterIndex.from_dict(doc[glbls.GROUP_PARAMETERS]) # Read values for all parameters. user_input = read(parameters.sorted(), files=files) args = [serialize_arg(key, val) for key, val in user_input.items()] # Start the run and print returned run state information. doc = api.runs().start_run(group_id=group_id, arguments=args, config=config) run_id = doc[labels.RUN_ID] run_state = doc[labels.RUN_STATE] click.echo('started run {} is {}'.format(run_id, run_state))
def login_user(ctx, username, password): """Login to to obtain access token.""" with service() as api: doc = api.users().login_user(username=username, password=password) # Get the access token from the response and print it to the console. token = doc[labels.USER_TOKEN] click.echo('export {}={}'.format(ctx.obj.vars['token'], token))
def delete_group(ctx, group, force): """Delete an existing user group.""" group_id = ctx.obj.get_group(ctx.params) if not force: # pragma: no cover msg = 'Do you really want to delete the group {}'.format(group_id) click.confirm(msg, default=True, abort=True) with service() as api: api.groups().delete_group(group_id) click.echo("Submission '{}' deleted.".format(group_id))
def list_users(): """List all registered users.""" with service() as api: doc = api.users().list_users() table = ResultTable(['Name', 'ID'], [PARA_STRING, PARA_STRING]) for user in doc[labels.USER_LIST]: table.add([user[labels.USER_NAME], user[labels.USER_ID]]) for line in table.format(): click.echo(line)
def delete_file(ctx, group, file, force): """Delete a previously uploaded file.""" group_id = ctx.obj.get_group(ctx.params) if not force: # pragma: no cover msg = 'Do you really want to delete file {}' click.confirm(msg, default=True, abort=True) with service() as api: api.uploads().delete_file(group_id=group_id, file_id=file) click.echo("File '{}' deleted.".format(file))
def download_result_archive(ctx, output, workflow): """Download post-processing result archive.""" workflow_id = ctx.obj.get_workflow(ctx.params) if workflow_id is None: raise click.UsageError('no workflow specified') with service() as api: buf = api.workflows().get_result_archive( workflow_id=workflow_id).open() with open(output, 'wb') as local_file: local_file.write(buf.read())
def register_user(username, password): """Register a new user.""" with service() as api: doc = api.users().register_user( username=username, password=password, verify=False ) user_id = doc[labels.USER_ID] click.echo('Registered {} with ID {}.'.format(username, user_id))
def list_groups(): """List user groups (for current user).""" with service() as api: doc = api.groups().list_groups() # Print listing of groups as output table. table = ResultTable(['ID', 'Name'], [PARA_STRING] * 2) for g in doc[labels.GROUP_LIST]: table.add([g[labels.GROUP_ID], g[labels.GROUP_NAME]]) for line in table.format(): click.echo(line)
def list_obsolete_runs(before, state): """List old runs.""" table = ResultTable(headline=['ID', 'Submitted at', 'State'], types=[PARA_STRING] * 3) with service() as api: runs = api.runs().run_manager.list_obsolete_runs(date=before, state=state) for run in runs: table.add([run.run_id, run.created_at[:19], run.state_type]) for line in table.format(): click.echo(line)
def update_group(ctx, group, name, members): """Update user group.""" if name is None and members is None: raise click.UsageError('nothing to update') group_id = ctx.obj.get_group(ctx.params) with service() as api: doc = api.groups().update_group( group_id=group_id, name=name, members=members.split(',') if members is not None else None) print_group(doc)
def upload_file(ctx, group, input): """Upload a file for a submission.""" group_id = ctx.obj.get_group(ctx.params) filename = os.path.basename(input) with service() as api: doc = api.uploads().upload_file(group_id=group_id, file=FSFile(input), name=filename) file_id = doc[labels.FILE_ID] name = doc[labels.FILE_NAME] click.echo('Uploaded \'{}\' with ID {}.'.format(name, file_id))
def create_group(ctx, workflow, name, members, configfile): """Create a new user group.""" workflow_id = ctx.obj.get_workflow(ctx.params) config = util.read_object(configfile) if configfile else None with service() as api: doc = api.groups().create_group( workflow_id=workflow_id, name=name, members=members.split(',') if members is not None else None, engine_config=config) group_id = doc[labels.GROUP_ID] click.echo('export {}={}'.format(ctx.obj.vars['group'], group_id))
def list_runs(ctx, group, state): """List workflow runs.""" group_id = ctx.obj.get_group(ctx.params) with service() as api: doc = api.runs().list_runs(group_id=group_id, state=state) table = ResultTable( headline=['ID', 'Submitted at', 'State'], types=[PARA_STRING] * 3 ) for r in doc[labels.RUN_LIST]: run = list([r[labels.RUN_ID], r[labels.RUN_CREATED][:19], r[labels.RUN_STATE]]) table.add(run) for line in table.format(): click.echo(line)
def update_workflow(ctx, name, description, instructions, workflow): """Update workflow properties.""" workflow_id = ctx.obj.get_workflow(ctx.params) # Ensure that at least one of the optional arguments is given if name is None and description is None and instructions is None: click.echo('nothing to update') else: with service() as api: api.workflows().update_workflow( workflow_id=workflow_id, name=name, description=description, instructions=read_instructions(instructions)) click.echo('updated workflow {}'.format(workflow_id))
def list_files(ctx, group): """List uploaded files for a submission.""" group_id = ctx.obj.get_group(ctx.params) with service() as api: doc = api.uploads().list_uploaded_files(group_id) table = ResultTable( headline=['ID', 'Name', 'Created At', 'Size'], types=[PARA_STRING, PARA_STRING, PARA_STRING, PARA_INT]) for f in doc['files']: table.add([ f[labels.FILE_ID], f[labels.FILE_NAME], f[labels.FILE_DATE][:19], f[labels.FILE_SIZE] ]) for line in table.format(): click.echo(line)
def list_workflows(): """List all workflows.""" count = 0 with service() as api: doc = api.workflows().list_workflows() for wf in doc[labels.WORKFLOW_LIST]: if count != 0: click.echo() count += 1 title = 'Workflow {}'.format(count) click.echo(title) click.echo('-' * len(title)) click.echo() click.echo('ID : {}'.format(wf[labels.WORKFLOW_ID])) click.echo('Name : {}'.format(wf[labels.WORKFLOW_NAME])) click.echo('Description : {}'.format( wf.get(labels.WORKFLOW_DESCRIPTION))) click.echo('Instructions: {}'.format( wf.get(labels.WORKFLOW_INSTRUCTIONS)))
def create_workflow(ctx, key, name, description, instructions, specfile, manifest, template, configfile, ignore_postproc): """Create a new workflow for a given template.""" config = util.read_object(configfile) if configfile else None with service() as api: # The create_workflow() method is only supported by the local API. If # an attempte is made to create a new workflow via a remote API an # error will be raised. doc = api.workflows().create_workflow( source=template, identifier=key, name=name, description=description, instructions=read_instructions(instructions), specfile=specfile, manifestfile=manifest, engine_config=config, ignore_postproc=ignore_postproc) workflow_id = doc[labels.WORKFLOW_ID] click.echo('export {}={}'.format(ctx.obj.vars['workflow'], workflow_id))
def get_workflow(ctx, workflow): """Print workflow properties.""" workflow_id = ctx.obj.get_workflow(ctx.params) with service() as api: doc = api.workflows().get_workflow(workflow_id=workflow_id) click.echo('ID : {}'.format(doc[labels.WORKFLOW_ID])) click.echo('Name : {}'.format(doc[labels.WORKFLOW_NAME])) click.echo('Description : {}'.format(doc.get(labels.WORKFLOW_DESCRIPTION))) click.echo('Instructions: {}'.format(doc.get( labels.WORKFLOW_INSTRUCTIONS))) if labels.POSTPROC_RUN in doc: postproc = doc[labels.POSTPROC_RUN] click.echo('\nPost-processing\n---------------') if rlbls.RUN_ERRORS in postproc: for msg in postproc[rlbls.RUN_ERRORS]: click.echo('{}'.format(msg)) elif rlbls.RUN_FILES in postproc: for f in postproc[rlbls.RUN_FILES]: click.echo('{} ({})'.format(f[flbls.FILE_ID], f[flbls.FILE_NAME]))
def whoami_user(ctx): """Print name of current user.""" with service() as api: doc = api.users().whoami_user(ctx.obj.access_token()) click.echo('Logged in as {}.'.format(doc[labels.USER_NAME]))
def download_result_file(file, output, run): """Download a run result file.""" with service() as api: buf = api.runs().get_result_file(run_id=run, file_id=file).open() with open(output, 'wb') as local_file: local_file.write(buf.read())
def download_result_archive(output, run): """Download archive of run result files.""" with service() as api: buf = api.runs().get_result_archive(run_id=run).open() with open(output, 'wb') as local_file: local_file.write(buf.read())
def delete_run(run): """Delete run.""" with service() as api: api.runs().delete_run(run_id=run) click.echo('run {} deleted.'.format(run))
def cancel_run(run): """Cancel active run.""" with service() as api: doc = api.runs().cancel_run(run_id=run) click.echo('run {} canceled.'.format(doc[labels.RUN_ID]))
def logout_user(ctx): """Logout from current user session.""" with service() as api: api.users().logout_user(ctx.obj.access_token()) click.echo('See ya mate!')
def show_group(ctx, group): """Show user group information.""" group_id = ctx.obj.get_group(ctx.params) with service() as api: doc = api.groups().get_group(group_id) print_group(doc)
def delete_workflow(ctx, workflow): """Delete an existing workflow and all runs.""" workflow_id = ctx.obj.get_workflow(ctx.params) with service() as api: api.workflows().delete_workflow(workflow_id=workflow_id) click.echo('workflow {} deleted.'.format(workflow_id))
def delete_obsolete_runs(before, state): """Delete old runs.""" with service() as api: count = api.runs().run_manager.delete_obsolete_runs(date=before, state=state) click.echo('{} runs deleted.'.format(count))