def show(identifiers, uuid, print_groups): from aiida.common.exceptions import NotExistent from aiida.common.exceptions import MultipleObjectsError if not is_dbenv_loaded(): load_dbenv() for id in identifiers: try: if uuid: try: n = load_node(uuid=id) except MultipleObjectsError: click.echo("More than one node found. Please provide " "longer starting pattern for uuid.", err=True) return else: try: ids = int(id) except ValueError: click.echo("The pk/id can not be a string. Please provide " "an integer.", err=True) return n = load_node(pk=int(ids)) print_node_info(n, print_groups=print_groups) except NotExistent as e: click.echo(e.message, err=True) sys.exit(1) if len(identifiers) > 1: click.echo("")
def calculation_gotocomputer(self, *args): """ Open a shell to the calc folder on the cluster This command opens a ssh connection to the scratch folder on the remote computer on which the calculation is being/has been executed. """ from aiida.common.exceptions import NotExistent if not is_dbenv_loaded(): load_dbenv() try: calc_id = args[0] except IndexError: print >> sys.stderr, "Pass as further argument a calculation ID or UUID." sys.exit(1) try: pk = int(calc_id) is_pk = True except ValueError: uuid = calc_id is_pk = False print "Loading environment..." from aiida.orm import JobCalculation try: if is_pk: calc = load_node(pk) else: calc = load_node(uuid) except NotExistent: print >> sys.stderr, "No node exists with ID={}.".format(calc_id) sys.exit(1) if not isinstance(calc, JobCalculation): print >> sys.stderr, "Node with ID={} is not a calculation; it is a {}".format( calc_id, calc.__class__.__name__) sys.exit(1) # get the transport try: t = calc._get_transport() except NotExistent as e: print >> sys.stderr, e.message sys.exit(1) # get the remote directory remotedir = calc._get_remote_workdir() if not remotedir: print >> sys.stderr, "No remote work directory is set for this calculation!" print >> sys.stderr, "(It is possible that the daemon did not submit the calculation yet)" sys.exit(1) # get the command to run (does not require to open the connection!) cmd_to_run = t.gotocomputer_command(remotedir) # Connect (execute command) print "Going the the remote folder..." # print cmd_to_run os.system(cmd_to_run)
def calculation_outputls(self, *args): """ Show the list of output files of a calculation node. It lists the files in the 'path' subdirectory of the output node of files retrieved by the parser. Therefore, this will not work before files are retrieved by the daemon. Use the -h option for more help on the command line options. """ import argparse from aiida.common.exceptions import NotExistent from aiida.cmdline.commands.node import list_repo_files parser = argparse.ArgumentParser( prog=self.get_full_command_name(), description='List ourput files in the repository folder.') parser.add_argument('calc', metavar='PK', type=int, help='The pk of the calculation') parser.add_argument('-p', '--path', type=str, default='', nargs='?', help="The relative path of the file you " "want to show. If not specified, show content" " of all the 'path' directory") parser.add_argument('-c', '--color', action='store_true', help="Color folders with a different color") args = list(args) parsed_args = parser.parse_args(args) if not is_dbenv_loaded(): load_dbenv() try: calc = load_node(parsed_args.calc) except NotExistent as e: print >> sys.stderr, e.message sys.exit(1) try: parsed_node = calc.out.retrieved except AttributeError: print >> sys.stderr, ("No 'retrieved' node found. Have the " "calculation files already been retrieved?") sys.exit(1) try: list_repo_files(parsed_node, os.path.join('path', parsed_args.path), parsed_args.color) except ValueError as e: print >> sys.stderr, e.message sys.exit(1)
def run(self, *args): """ Show node information. """ import argparse from aiida.common.exceptions import NotExistent parser = argparse.ArgumentParser( prog=self.get_full_command_name(), description='Show information of a node.') parser.add_argument('pk', type=int, default=None, nargs="+", help="ID of the node.") parser.add_argument('-d', '--depth', action='store', default=1, metavar="N", type=int, help="Add children of shown nodes up to Nth " "level. Default 0") args = list(args) parsed_args = parser.parse_args(args) if not is_dbenv_loaded(): load_dbenv() for pk in parsed_args.pk: try: n = load_node(pk) self.print_node_tree(n, parsed_args.depth) except NotExistent as e: print >> sys.stderr, e.message sys.exit(1) if len(parsed_args.pk) > 1: print ""
def comment_remove(self, *args): """ Remove comments. The user can only remove its own comments """ # Note: in fact, the user can still manually delete any comment import argparse from aiida.backends.utils import get_automatic_user if not is_dbenv_loaded(): load_dbenv() user = get_automatic_user() parser = argparse.ArgumentParser( prog=self.get_full_command_name(), description='Remove comments of a node.') parser.add_argument('pk', metavar='PK', type=int, help='The pk (an integer) of the node') parser.add_argument('id', metavar='ID', type=int, default=None, nargs='?', help='#ID of the comment to be removed from node #PK') parser.add_argument('-a', '--all', action='store_true', default=False, help='If used, deletes all the comments of the active user attached to the node') parsed_args = parser.parse_args(args) if parsed_args.id is None and not parsed_args.all: print "One argument between -a and ID must be provided" sys.exit(1) if parsed_args.id is not None and parsed_args.all: print "Only one between -a and ID should be provided" sys.exit(1) node = load_node(parsed_args.pk) allowed_trues = ['1', 't', 'true', 'y', 'yes'] if parsed_args.all: sys.stdout.write("Delete all comments of user {}? ".format(user)) inpread = sys.stdin.readline() do_I_delete = True if inpread.strip().lower() in allowed_trues else False if not do_I_delete: print "Not deleting comment. Aborting." sys.exit(1) else: comments = node.get_comment_obj(user=user) for comment in comments: comment.delete() print("Deleted {} comments.".format(len(comments))) else: sys.stdout.write("Delete comment? ") inpread = sys.stdin.readline() do_I_delete = True if inpread.strip().lower() in allowed_trues else False if not do_I_delete: print "Not deleting comment. Aborting." sys.exit(1) else: from aiida.orm.implementation import Comment as CommentOrm c = CommentOrm(id=parsed_args.id, user=user) c.delete()
def calculation_inputcat(self, *args): """ Show an input file of a calculation node. It shows the files in the raw_input subdirectory. Use the -h option for more help on the command line options. """ from aiida.cmdline.commands.node import cat_repo_files from aiida.common.exceptions import NotExistent import argparse parser = argparse.ArgumentParser( prog=self.get_full_command_name(), description='Output the content of a file in the repository folder.') parser.add_argument('calc', metavar='PK', type=int, help='The pk of the calculation') parser.add_argument('-p', '--path', type=str, default=None, nargs='?', help="The relative path of the file you " "want to show. Take the default input file if " "it is not specified") args = list(args) parsed_args = parser.parse_args(args) if not is_dbenv_loaded(): load_dbenv() from aiida.common.old_pluginloader import get_class_typestring try: calc = load_node(parsed_args.calc) except NotExistent as e: print >> sys.stderr, e.message sys.exit(1) path = parsed_args.path if path is None: path = calc._DEFAULT_INPUT_FILE if path is None: base_class, plugin_string, class_name = get_class_typestring( calc._plugin_type_string) print >> sys.stderr, ("Calculation '{}' does not define a " "default input file. Please specify a path " "explicitly".format(plugin_string)) sys.exit(1) try: cat_repo_files(calc, os.path.join('raw_input', path)) except ValueError as e: print >> sys.stderr, e.message sys.exit(1) except IOError as e: import errno # Ignore Broken pipe errors, re-raise everything else if e.errno == errno.EPIPE: pass else: raise
def calculation_res(self, *args): """ Print all or somoe data from the "res" output node. """ from aiida.common.exceptions import NotExistent from aiida.cmdline import print_dictionary import argparse parser = argparse.ArgumentParser( prog=self.get_full_command_name(), description='Show calculation results (from calc.res)') parser.add_argument('PK', type=int, default=None, help="PK of the calculation object whose results " "must be shown.") parser.add_argument('-f', '--format', type=str, default='json+date', help="Format for the output.") parser.add_argument('-k', '--keys', nargs='+', type=str, help="Show only the selected keys.") args = list(args) parsed_args = parser.parse_args(args) if not is_dbenv_loaded(): load_dbenv() try: calc = load_node(int(parsed_args.PK)) except ValueError: print >> sys.stderr, "*** {}: Not a valid PK".format( parsed_args.PK) sys.exit(1) except NotExistent: print >> sys.stderr, "*** {}: Not a valid calculation".format( parsed_args.PK) sys.exit(1) full_dict = calc.res._get_dict() if parsed_args.keys: try: the_dict = {k: full_dict[k] for k in parsed_args.keys} except KeyError as e: print >> sys.stderr, ("The key '{}' was not found in the .res " "dictionary".format(e.message)) sys.exit(1) else: # Return all elements the_dict = full_dict print_dictionary(the_dict, format=parsed_args.format)
def comment_update(self, *args): """ Update a comment """ import argparse from aiida.backends.utils import get_automatic_user if not is_dbenv_loaded(): load_dbenv() user = get_automatic_user() parser = argparse.ArgumentParser( prog=self.get_full_command_name(), description='Add a comment to a node in the database.') parser.add_argument('pk', metavar='PK', type=int, help='The pk (an integer) of the node') parser.add_argument('id', metavar='ID', type=int, help='Identify the comment to update by ID') parser.add_argument( '-c', '--comment', type=str, default=None, help='The comment (a string) to be added to the node') parsed_args = parser.parse_args(args) # read the comment from terminal if it is not on command line if parsed_args.comment is None: print "Write below the comment that you want to save in the database." print " # This is a multiline input, press CTRL+D on a" print " # empty line when you finish" try: newlines = [] while True: input_txt = raw_input() if input_txt.strip() == '?': print "\n".join([ " > {}".format(descl) for descl in "HELP: {}".format(desc).split('\n') ]) continue else: newlines.append(input_txt) except EOFError: # Ctrl+D pressed: end of input. pass the_comment = "\n".join(newlines) else: the_comment = parsed_args.comment node = load_node(parsed_args.pk) node._update_comment(the_comment, parsed_args.id, user)
def calculation_logshow(self, *args): from aiida.common.exceptions import NotExistent from aiida.backends.utils import get_log_messages from aiida.common.datastructures import calc_states if not is_dbenv_loaded(): load_dbenv() for calc_pk in args: try: calc = load_node(int(calc_pk)) except ValueError: print "*** {}: Not a valid PK".format(calc_pk) continue except NotExistent: print "*** {}: Not a valid calculation".format(calc_pk) continue log_messages = get_log_messages(calc) label_string = " [{}]".format(calc.label) if calc.label else "" state = calc.get_state() if state == calc_states.WITHSCHEDULER: sched_state = calc.get_scheduler_state() if sched_state is None: sched_state = "(unknown)" state += ", scheduler state: {}".format(sched_state) print "*** {}{}: {}".format(calc_pk, label_string, state) sched_out = calc.get_scheduler_output() sched_err = calc.get_scheduler_error() if sched_out is None: print "*** Scheduler output: N/A" elif sched_out: print "*** Scheduler output:" print sched_out else: print "*** (empty scheduler output file)" if sched_err is None: print "*** Scheduler errors: N/A" elif sched_err: print "*** Scheduler errors:" print sched_err else: print "*** (empty scheduler errors file)" if log_messages: print "*** {} LOG MESSAGES:".format(len(log_messages)) else: print "*** 0 LOG MESSAGES" for log in log_messages: print "+-> {} at {}".format(log['levelname'], log['time']) # Print the message, with a few spaces in front of each line print "\n".join( ["| {}".format(_) for _ in log['message'].splitlines()])
def calculation_kill(self, *args): """ Kill a calculation. Pass a list of calculation PKs to kill them. If you also pass the -f option, no confirmation will be asked. """ if not is_dbenv_loaded(): load_dbenv() from aiida.cmdline import wait_for_confirmation from aiida.orm.calculation.job import JobCalculation as Calc from aiida.common.exceptions import NotExistent, InvalidOperation, \ RemoteOperationError import argparse parser = argparse.ArgumentParser( prog=self.get_full_command_name(), description='Kill AiiDA calculations.') parser.add_argument( 'calcs', metavar='PK', type=int, nargs='+', help='The principal key (PK) of the calculations to kill') parser.add_argument('-f', '--force', help='Force the kill of calculations', action="store_true") args = list(args) parsed_args = parser.parse_args(args) if not parsed_args.force: sys.stderr.write( "Are you sure to kill {} calculation{}? [Y/N] ".format( len(parsed_args.calcs), "" if len(parsed_args.calcs) == 1 else "s")) if not wait_for_confirmation(): sys.exit(0) counter = 0 for calc_pk in parsed_args.calcs: try: c = load_node(calc_pk, parent_class=Calc) c.kill() # Calc.kill(calc_pk) counter += 1 except NotExistent: print >> sys.stderr, ("WARNING: calculation {} " "does not exist.".format(calc_pk)) except (InvalidOperation, RemoteOperationError) as e: print >> sys.stderr, (e.message) print >> sys.stderr, "{} calculation{} killed.".format( counter, "" if counter == 1 else "s")
def comment_show(self, *args): """ Show the comments of a node """ import argparse from aiida.backends.utils import get_automatic_user if not is_dbenv_loaded(): load_dbenv() user = get_automatic_user() parser = argparse.ArgumentParser( prog=self.get_full_command_name(), description='Show the comments of a node in the database.') parser.add_argument('-u', '--user', type=str, default=None, help='Show only the comments of a given user (optional).') parser.add_argument('pk', metavar='PK', type=int, help='The pk (an integer) of the node.') parser.add_argument('id', metavar='ID', type=int, default=None, nargs='?', help='The id (an integer) of the comment.') # Note that this is a false description, I'm using the DBComment.pk parsed_args = parser.parse_args(args) node = load_node(parsed_args.pk) all_comments = node.get_comments(pk=parsed_args.id) if parsed_args.user is not None: to_print = [i for i in all_comments if i['user__email'] == parsed_args.user] if not to_print: print "Nothing found for user '{}'.".format(parsed_args.user) print "Valid users found for Node {} are: {}.".format(parsed_args.pk, ", ".join(set( ["'" + i['user__email'] + "'" for i in all_comments]))) else: to_print = all_comments if parsed_args.id is not None: to_print = [i for i in to_print if i['pk'] == parsed_args.id] for i in to_print: print "***********************************************************" print "Comment of '{}' on {}".format(i['user__email'], i['ctime'].strftime("%Y-%m-%d %H:%M")) print "ID: {}. Last modified on {}".format(i['pk'], i['mtime'].strftime("%Y-%m-%d %H:%M")) print "" print "{}".format(i['content']) print "" # If there is nothing to print, print a message if not to_print: print "No comment found."
def calculation_inputls(self, *args): """ Show the list of input files of a calculation node. It shows the files in the raw_input subdirectory. Use the -h option for more help on the command line options. """ import argparse from aiida.common.exceptions import NotExistent from aiida.cmdline.commands.node import list_repo_files parser = argparse.ArgumentParser( prog=self.get_full_command_name(), description='List input files in the repository folder.') parser.add_argument('calc', metavar='PK', type=int, help='The pk of the calculation') parser.add_argument('-p', '--path', type=str, default='', nargs='?', help="The relative path of the file you " "want to show. If not specified, show content" " of all the 'raw_input' directory") parser.add_argument('-c', '--color', action='store_true', help="Color folders with a different color") args = list(args) parsed_args = parser.parse_args(args) if not is_dbenv_loaded(): load_dbenv() try: calc = load_node(parsed_args.calc) except NotExistent as e: print >> sys.stderr, e.message sys.exit(1) try: list_repo_files(calc, os.path.join('raw_input', parsed_args.path), parsed_args.color) except ValueError as e: print >> sys.stderr, e.message sys.exit(1)
def ls(self, *args): """ List the files in the repository folder. """ import argparse from aiida.common.exceptions import NotExistent parser = argparse.ArgumentParser( prog=self.get_full_command_name(), description='List files in the repository folder.') parser.add_argument('-c', '--color', action='store_true', help="Color folders with a different color") parser.add_argument('-p', '--pk', type=int, required=True, help='The pk of the node') parser.add_argument('path', type=str, default='.', nargs='?', help='The relative path of the file you ' 'want to show') # parser.add_argument('-d', '--with-description', # dest='with_description',action='store_true', # help="Show also the description for the UPF family") # parser.set_defaults(with_description=False) args = list(args) parsed_args = parser.parse_args(args) if not is_dbenv_loaded(): load_dbenv() try: n = load_node(parsed_args.pk) except NotExistent as e: print >> sys.stderr, e.message sys.exit(1) try: list_repo_files(n, parsed_args.path, parsed_args.color) except ValueError as e: print >> sys.stderr, e.message sys.exit(1)
def cat(self, *args): """ Output the content of a file in the repository folder. """ import argparse from aiida.common.exceptions import NotExistent parser = argparse.ArgumentParser( prog=self.get_full_command_name(), description='Output the content of a file in the repository folder.' ) parser.add_argument('-p', '--pk', type=int, required=True, help='The pk of the node') parser.add_argument('path', type=str, help='The relative path of the file you ' 'want to show') args = list(args) parsed_args = parser.parse_args(args) if not is_dbenv_loaded(): load_dbenv() try: n = load_node(parsed_args.pk) except NotExistent as e: print >> sys.stderr, e.message sys.exit(1) try: cat_repo_files(n, parsed_args.path) except ValueError as e: print >> sys.stderr, e.message sys.exit(1) except IOError as e: import errno # Ignore Broken pipe errors, re-raise everything else if e.errno == errno.EPIPE: pass else: raise
def run(self, *args): """ Show node information. """ import argparse from aiida.common.exceptions import NotExistent parser = argparse.ArgumentParser( prog=self.get_full_command_name(), description='Show information of a node.') parser.add_argument('pk', type=int, default=None, nargs="+", help="ID of the node.") parser.add_argument('--print-groups', action='store_true', dest='print_groups', default=False, help="Show groups containing the nodes.") parser.add_argument('--no-print-groups', '--dont-print-groups', action='store_false', dest='print_groups', default=False, help="Do not show groups containing the nodes" "output. Default behaviour.") args = list(args) parsed_args = parser.parse_args(args) if not is_dbenv_loaded(): load_dbenv() for pk in parsed_args.pk: try: n = load_node(pk) self.print_node_info(n, print_groups=parsed_args.print_groups) except NotExistent as e: print >> sys.stderr, e.message sys.exit(1) if len(parsed_args.pk) > 1: print ""
def calculation_show(self, *args): from aiida.common.exceptions import NotExistent from aiida.cmdline.common import print_node_info if not is_dbenv_loaded(): load_dbenv() table_headers = ['Link label', 'PK', 'Type'] for calc_pk in args: try: calc = load_node(int(calc_pk)) except ValueError: print "*** {}: Not a valid PK".format(calc_pk) continue except NotExistent: print "*** {}: Not a valid calculation".format(calc_pk) continue print_node_info(calc)
def group_list(self, *args): """ Print a list of groups in the DB. """ if not is_dbenv_loaded(): load_dbenv() import datetime from aiida.utils import timezone from aiida.orm.group import get_group_type_mapping from aiida.backends.utils import get_automatic_user from tabulate import tabulate parser = argparse.ArgumentParser( prog=self.get_full_command_name(), description='List AiiDA user-defined groups.') exclusive_group = parser.add_mutually_exclusive_group() exclusive_group.add_argument('-A', '--all-users', dest='all_users', action='store_true', help="Show groups for all users, rather than only for the current user") exclusive_group.add_argument('-u', '--user', metavar='USER_EMAIL', help="Add a filter to show only groups belonging to a specific user", action='store', type=str) parser.add_argument('-t', '--type', metavar='TYPE', help="Show groups of a specific type, instead of user-defined groups", action='store', type=str) parser.add_argument('-d', '--with-description', dest='with_description', action='store_true', help="Show also the group description") parser.add_argument('-p', '--past-days', metavar='N', help="add a filter to show only groups created in the past N days", action='store', type=int) parser.add_argument('-s', '--startswith', metavar='STRING', default=None, help="add a filter to show only groups for which the name begins with STRING", action='store', type=str) parser.add_argument('-e', '--endswith', metavar='STRING', default=None, help="add a filter to show only groups for which the name ends with STRING", action='store', type=str) parser.add_argument('-c', '--contains', metavar='STRING', default=None, help="add a filter to show only groups for which the name contains STRING", action='store', type=str) parser.add_argument('-n', '--node', metavar='PK', default=None, help="Show only the groups that contain the node specified by PK", action='store', type=int) parser.set_defaults(all_users=False) parser.set_defaults(with_description=False) args = list(args) parsed_args = parser.parse_args(args) if parsed_args.all_users: user = None else: if parsed_args.user: user = parsed_args.user else: # By default: only groups of this user user = get_automatic_user() type_string = "" if parsed_args.type is not None: try: type_string = get_group_type_mapping()[parsed_args.type] except KeyError: print >> sys.stderr, "Invalid group type. Valid group types are:" print >> sys.stderr, ",".join(sorted( get_group_type_mapping().keys())) sys.exit(1) name_filters = dict((k, getattr(parsed_args, k)) for k in ['startswith', 'endswith', 'contains']) n_days_ago = None if parsed_args.past_days: n_days_ago = (timezone.now() - datetime.timedelta(days=parsed_args.past_days)) # Depending on --nodes option use or not key "nodes" from aiida.orm.implementation import Group from aiida.orm import load_node node_pk = parsed_args.node if node_pk is not None: try: node = load_node(node_pk) except NotExistent as e: print >> sys.stderr, "Error: {}.".format(e.message) sys.exit(1) res = Group.query(user=user, type_string=type_string, nodes=node, past_days=n_days_ago, name_filters=name_filters) else: res = Group.query(user=user, type_string=type_string, past_days=n_days_ago, name_filters=name_filters) groups = tuple([(str(g.pk), g.name, len(g.nodes), g.user.email.strip(), g.description) for g in res]) table = [] if parsed_args.with_description: table_header = \ ["PK", "GroupName", "NumNodes", "User", "Description"] for pk, nam, nod, usr, desc in groups: table.append([pk, nam, nod, usr, desc]) else: table_header = ["PK", "GroupName", "NumNodes", "User"] for pk, nam, nod, usr, _ in groups: table.append([pk, nam, nod, usr]) print(tabulate(table, headers=table_header))
def group_removenodes(self, *args): """ Remove nodes from a given group. """ from aiida.cmdline import delayed_load_node as load_node from aiida.cmdline import wait_for_confirmation if not is_dbenv_loaded(): load_dbenv() import argparse from aiida.common.exceptions import NotExistent from aiida.orm import Group as G parser = argparse.ArgumentParser( prog=self.get_full_command_name(), description='Remove nodes from a given AiiDA group.') parser.add_argument('-g', '--group', dest='group', required=True, help="The name or PK of the group you want to " "remove a node from.") parser.add_argument('nodes', nargs='+', help="The PK or UUID of the nodes to remove. An " "error is raised if the node does not exist. " "No message is shown if the node does not belong " "to the group.") parser.set_defaults(raw=False) args = list(args) parsed_args = parser.parse_args(args) group = parsed_args.group try: group_pk = int(group) except ValueError: group_pk = None group_name = group if group_pk is not None: try: group = G(dbgroup=group_pk) except NotExistent as e: print >> sys.stderr, "Error: {}.".format(e.message) sys.exit(1) else: try: group = G.get_from_string(group_name) except NotExistent as e: print >> sys.stderr, "Error: {}.".format(e.message) sys.exit(1) group_pk = group.pk group_name = group.name nodes = [] for node in parsed_args.nodes: try: node = int(node) except ValueError: pass # I leave it as a string and let load_node complain # if it is not a UUID try: nodes.append(load_node(node)) except NotExistent as e: print >> sys.stderr, "Error: {}.".format(e.message) sys.exit(1) sys.stderr.write("Are you sure to remove {} nodes from the group " "with PK = {} " "({})? [Y/N] ".format(len(nodes), group_pk, group_name)) if not wait_for_confirmation(): sys.exit(0) group.remove_nodes(nodes)
def run(self, *args): if not is_dbenv_loaded(): load_dbenv() import argparse from aiida.cmdline import wait_for_confirmation parser = argparse.ArgumentParser(prog=self.get_full_command_name(), description="See description of Nodes. If no node " "description or label is found, prints n.a.") # parameters for display parser.add_argument('-n', '--no-labels', action='store_false', default=True, help="Don't show the labels.") parser.add_argument('-r', '--raw', action='store_true', default=False, help="If set, prints only the description without " "pks or labels.") # pks parser.add_argument('pks', type=int, nargs='+', help="a list of node pks to show.") # parameters for description modifications parser.add_argument('-s', '--set', action='store_true', default=False, help="If present, set a new label, otherwise only " "show the labels.") parser.add_argument('-a', '--add-to-description', action='store_true', default=False, help="If -s, the string passed in -d is appended " "to the current description.") parser.add_argument('-f', '--force', action='store_true', default=False, help="Force the reset of the description.") parser.add_argument('-d', '--description', type=str, help="The new description to be set on the node. " "Note: pass it between quotes.") parsed_args = parser.parse_args(args) pks = parsed_args.pks if not parsed_args.set: also_labels = parsed_args.no_labels for pk in pks: n = load_node(pk) if not self._node_class_ok(n): print "Node {} is not a subclass of {}. Exiting...".format( pk, self._node_subclass) sys.exit(1) label = n.label description = n.description if parsed_args.raw: print '"{}"'.format(n.description) print "" else: print "Node pk: {}".format(pk) if also_labels: if label: print 'Label: "{}"'.format(label) else: print 'Label: n.a.' if description: print 'Description: "{}"'.format(description) else: print 'Description: n.a.' print "" else: # check that only one pk is present if len(pks) > 1: sys.stderr.write( "More than one node found to set one description" ". Exiting...\n") sys.exit(1) else: pk = pks[0] new_description = parsed_args.description if new_description is None: sys.stderr.write("No description was found. Exiting...\n") sys.exit(1) if not parsed_args.add_to_description: n = load_node(pk) if not self._node_class_ok(n): print "Node {} is not a subclass of {}. Exiting...".format( pk, self._node_subclass) sys.exit(1) old_description = n.description if not parsed_args.force: sys.stderr.write( "Current description is: {}\n".format(old_description)) sys.stderr.write( "New description is: {}\n".format(new_description)) sys.stderr.write( "Are you sure you want to reset the description? " "[Y/N] ") if not wait_for_confirmation(): sys.exit(0) n.description = new_description else: n = load_node(pk) if not self._node_class_ok(n): print "Node {} is not a subclass of {}. Exiting...".format( pk, self._node_subclass) sys.exit(1) old_description = n.description new_description = old_description + "\n" + new_description n.description = new_description
def run(self, *args): if not is_dbenv_loaded(): load_dbenv() import argparse from aiida.cmdline import wait_for_confirmation parser = argparse.ArgumentParser(prog=self.get_full_command_name(), description="See/modify the labels of Nodes.") # display parameters parser.add_argument('-r', '--raw', action='store_true', default=False, help="Display only the labels, without the pk.") # pks parser.add_argument('pks', type=int, nargs='+', help="a list of nodes to show.") # parameters for label modification parser.add_argument('-s', '--set', action='store_true', default=False, help="If present, set a new label, otherwise only " "show the labels.") parser.add_argument('-f', '--force', action='store_true', default=False, help="Force the reset of the label.") parser.add_argument('-l', '--label', type=str, default=None, help="The new label to be set on the node. Note: " "pass it between quotes.") parsed_args = parser.parse_args(args) raw = parsed_args.raw pks = parsed_args.pks if not parsed_args.set: for pk in pks: n = load_node(pk) if not self._node_class_ok(n): print "Node {} is not a subclass of {}. Exiting...".format( pk, self._node_subclass) sys.exit(1) if raw: print '"{}"'.format(n.label) else: if not n.label: print 'Node {}, label: n.a.'.format(pk) else: print 'Node {}, label: "{}"'.format(pk, n.label) else: if len(pks) > 1: sys.stderr.write("More than one node found to set one label" ". Exiting...\n") sys.exit(1) else: pk = pks[0] new_label = parsed_args.label if new_label is None: sys.stderr.write("A new label is required" ". Exiting...\n") sys.exit(1) n = load_node(pk) if not self._node_class_ok(n): print "Node {} is not a subclass of {}. Exiting...".format(pk, self._node_subclass) sys.exit(1) old_label = n.label if not parsed_args.force: sys.stderr.write("Current label is: {}\n".format(old_label)) sys.stderr.write("New label is: {}\n".format(new_label)) sys.stderr.write("Are you sure you want to reset the label? " "[Y/N] ") if not wait_for_confirmation(): sys.exit(0) n.label = new_label