def group_description(self, *args):
"""
Edit the group description.
"""
if not is_dbenv_loaded():
load_dbenv()
import argparse
from aiida.orm import Group as G
from aiida.common.exceptions import NotExistent
parser = argparse.ArgumentParser(
prog=self.get_full_command_name(),
description='Change the description of a given group.')
parser.add_argument('PK', type=int,
help="The PK of the group for which "
"you want to edit the description")
parser.add_argument('description', type=str,
help="The new description. If not provided, "
"just show the current description.")
args = list(args)
parsed_args = parser.parse_args(args)
group_pk = parsed_args.PK
try:
group = G(dbgroup=group_pk)
except NotExistent as e:
print >> sys.stderr, "Error: {}.".format(e.message)
sys.exit(1)
group.description = parsed_args.description
def group_delete(self, *args):
"""
Delete an existing group.
"""
if not is_dbenv_loaded():
load_dbenv()
import argparse
from aiida.common.exceptions import NotExistent
from aiida.orm import Group as G
from aiida.cmdline import wait_for_confirmation
parser = argparse.ArgumentParser(
prog=self.get_full_command_name(),
description='Delete an existing group.')
parser.add_argument('-f', '--force',
dest='force', action='store_true',
help="Force deletion of the group even if it "
"is not empty. Note that this deletes only the "
"group and not the nodes.")
parser.add_argument('GROUP',
help="The name or PK of the group to delete")
parser.set_defaults(force=False)
args = list(args)
parsed_args = parser.parse_args(args)
group = parsed_args.GROUP
force = parsed_args.force
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
num_nodes = len(group.nodes)
if num_nodes > 0 and not force:
print >> sys.stderr, ("Group '{}' is not empty (it contains {} "
"nodes). Pass the -f option if you really want to delete "
"it.".format(group_name, num_nodes))
sys.exit(1)
sys.stderr.write("Are you sure to kill the group with PK = {} ({})? "
"[Y/N] ".format(group_pk, group_name))
if not wait_for_confirmation():
sys.exit(0)
group.delete()
print "Group '{}' (PK={}) deleted.".format(group_name, group_pk)
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 group_show(self, *args):
"""
Show information on a given group. Pass the PK as a parameter.
"""
if not is_dbenv_loaded():
load_dbenv()
import argparse
from aiida.common.exceptions import NotExistent
from aiida.orm import Group as G
from aiida.common.utils import str_timedelta
from aiida.utils import timezone
from aiida.common.pluginloader import from_type_to_pluginclassname
from tabulate import tabulate
parser = argparse.ArgumentParser(
prog=self.get_full_command_name(),
description='Information on a given AiiDA group.')
parser.add_argument('-r', '--raw',
dest='raw', action='store_true',
help="Show only a space-separated list of PKs of "
"the calculations in the group")
parser.add_argument('-u', '--uuid',
dest='uuid', action='store_true',
help="Show UUIDs together with PKs. Note: if the "
"--raw option is also passed, PKs are not "
"printed, but oly UUIDs.")
parser.add_argument('GROUP', help="The PK of the group to show")
parser.set_defaults(raw=False)
parser.set_defaults(uuid=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
if parsed_args.raw:
if parsed_args.uuid:
print " ".join(str(_.uuid) for _ in group.nodes)
else:
print " ".join(str(_.pk) for _ in group.nodes)
else:
type_string = group.type_string
desc = group.description
now = timezone.now()
table = []
table.append(["Group name", group.name])
table.append(["Group type",
type_string if type_string else "<user-defined>"])
table.append(["Group description",
desc if desc else "<no description>"])
print(tabulate(table))
table = []
header = []
if parsed_args.uuid:
header.append('UUID')
header.extend(['PK', 'Type', 'Created'])
print "# Nodes:"
for n in group.nodes:
row = []
if parsed_args.uuid:
row.append(n.uuid)
row.append(n.pk)
row.append(from_type_to_pluginclassname(n.dbnode.type).
rsplit(".", 1)[1])
row.append(str_timedelta(now - n.ctime, short=True,
negative_to_zero=True))
table.append(row)
print(tabulate(table, headers=header))