def nodeset():
"""script subroutine"""
class_set = NodeSet
usage = "%prog [COMMAND] [OPTIONS] [ns1 [-ixX] ns2|...]"
parser = OptionParser(usage)
parser.install_nodeset_commands()
parser.install_nodeset_operations()
parser.install_nodeset_options()
(options, args) = parser.parse_args()
if options.debug:
STD_GROUP_RESOLVER.set_verbosity(1)
# Check for command presence
cmdcount = int(options.count) + int(options.expand) + \
int(options.fold) + int(bool(options.list)) + \
int(options.regroup) + int(options.groupsources)
if not cmdcount:
parser.error("No command specified.")
elif cmdcount > 1:
parser.error("Multiple commands not allowed.")
if options.rangeset:
class_set = RangeSet
if options.all or options.regroup:
assert class_set == NodeSet, "-a/-r only supported in NodeSet mode"
if options.groupsource and not options.quiet and \
(class_set == RangeSet or options.groupsources):
print >> sys.stderr, "WARNING: option group source \"%s\" ignored" \
% options.groupsource
# The list command doesn't need any NodeSet, check for it first.
if options.list > 0:
list_level = options.list
for group in grouplist(options.groupsource):
if options.groupsource and not options.groupbase:
nsgroup = "@%s:%s" % (options.groupsource, group)
else:
nsgroup = "@%s" % group
if list_level == 1:
print nsgroup
else:
nodes = NodeSet(nsgroup)
if list_level == 2: # -ll ?
print "%s %s" % (nsgroup, nodes)
else: # -lll ?
print "%s %s %d" % (nsgroup, nodes, len(nodes))
return
# Also, the groupsources command simply lists group sources.
elif options.groupsources:
if options.quiet:
dispdefault = "" # don't show (default) if quiet is set
else:
dispdefault = " (default)"
for src in STD_GROUP_RESOLVER.sources():
print "%s%s" % (src, dispdefault)
dispdefault = ""
return
# We want -s <groupsource> to act as a substition of default groupsource
# (ie. it's not necessary to prefix group names by this group source).
if options.groupsource:
STD_GROUP_RESOLVER.default_sourcename = options.groupsource
# Instantiate RangeSet or NodeSet object
xset = class_set(autostep=options.autostep)
if options.all:
# Include all nodes from external node groups support.
xset.update(NodeSet.fromall()) # uses default_sourcename
elif not args:
# No need to specify '-' to read stdin if no argument at all.
process_stdin(xset.update, xset.__class__, options.autostep)
# Apply first operations (before first non-option)
for nodes in options.and_nodes:
if nodes == '-':
process_stdin(xset.intersection_update, xset.__class__,
options.autostep)
else:
xset.intersection_update(class_set(nodes,
autostep=options.autostep))
for nodes in options.sub_nodes:
if nodes == '-':
process_stdin(xset.difference_update, xset.__class__,
options.autostep)
else:
xset.difference_update(class_set(nodes, autostep=options.autostep))
for nodes in options.xor_nodes:
if nodes == '-':
process_stdin(xset.symmetric_difference_update, xset.__class__,
options.autostep)
else:
xset.symmetric_difference_update(class_set(nodes, \
autostep=options.autostep))
# Finish xset computing from args
compute_nodeset(xset, args, options.autostep)
# Interprate special characters (may raise SyntaxError)
separator = eval('\'%s\'' % options.separator, {"__builtins__":None}, {})
if options.slice_rangeset:
_xset = class_set()
for sli in RangeSet(options.slice_rangeset).slices(False):
_xset.update(xset[sli])
xset = _xset
# Display result according to command choice
if options.expand:
xsubres = separator.join
elif options.fold:
xsubres = lambda x: x
elif options.regroup:
xsubres = lambda x: x.regroup(options.groupsource, \
noprefix=options.groupbase)
else:
xsubres = len
if not xset or options.maxsplit <= 1:
print xsubres(xset)
else:
for xsubset in xset.split(options.maxsplit):
print xsubres(xsubset)
def nodeset():
"""script subroutine"""
class_set = NodeSet
usage = "%prog [COMMAND] [OPTIONS] [ns1 [-ixX] ns2|...]"
parser = OptionParser(usage)
parser.install_nodeset_commands()
parser.install_nodeset_operations()
parser.install_nodeset_options()
(options, args) = parser.parse_args()
group_resolver = std_group_resolver()
if options.debug:
logging.basicConfig(level=logging.DEBUG)
# Check for command presence
cmdcount = int(options.count) + int(options.expand) + \
int(options.fold) + int(bool(options.list)) + \
int(bool(options.listall)) + int(options.regroup) + \
int(options.groupsources)
if not cmdcount:
parser.error("No command specified.")
elif cmdcount > 1:
parser.error("Multiple commands not allowed.")
if options.rangeset:
class_set = RangeSet
if options.all or options.regroup:
if class_set != NodeSet:
parser.error("-a/-r only supported in NodeSet mode")
if options.maxsplit is not None and options.contiguous:
parser.error("incompatible splitting options (split, contiguous)")
if options.maxsplit is None:
options.maxsplit = 1
if options.axis and (not options.fold or options.rangeset):
parser.error("--axis option is only supported when folding nodeset")
if options.groupsource and not options.quiet and class_set == RangeSet:
print >> sys.stderr, "WARNING: option group source \"%s\" ignored" \
% options.groupsource
# We want -s <groupsource> to act as a substition of default groupsource
# (ie. it's not necessary to prefix group names by this group source).
if options.groupsource:
group_resolver.default_source_name = options.groupsource
# The groupsources command simply lists group sources.
if options.groupsources:
if options.quiet:
dispdefault = "" # don't show (default) if quiet is set
else:
dispdefault = " (default)"
for src in group_resolver.sources():
print "%s%s" % (src, dispdefault)
dispdefault = ""
return
autostep = options.autostep
# Do not use autostep for computation when a percentage or the special
# value 'auto' is specified. Real autostep value is set post-process.
if type(autostep) is float or autostep == 'auto':
autostep = None
# Instantiate RangeSet or NodeSet object
xset = class_set(autostep=autostep)
if options.all:
# Include all nodes from external node groups support.
xset.update(NodeSet.fromall()) # uses default_source when set
if not args and not options.all and not (options.list or options.listall):
# No need to specify '-' to read stdin in these cases
process_stdin(xset.update, xset.__class__, autostep)
# Apply first operations (before first non-option)
for nodes in options.and_nodes:
if nodes == '-':
process_stdin(xset.intersection_update, xset.__class__, autostep)
else:
xset.intersection_update(class_set(nodes, autostep=autostep))
for nodes in options.sub_nodes:
if nodes == '-':
process_stdin(xset.difference_update, xset.__class__, autostep)
else:
xset.difference_update(class_set(nodes, autostep=autostep))
for nodes in options.xor_nodes:
if nodes == '-':
process_stdin(xset.symmetric_difference_update, xset.__class__,
autostep)
else:
xset.symmetric_difference_update(class_set(nodes,
autostep=autostep))
# Finish xset computing from args
compute_nodeset(xset, args, autostep)
# The list command has a special handling
if options.list > 0 or options.listall > 0:
return command_list(options, xset, group_resolver)
# Interprete special characters (may raise SyntaxError)
separator = eval('\'%s\'' % options.separator, {"__builtins__":None}, {})
if options.slice_rangeset:
_xset = class_set()
for sli in RangeSet(options.slice_rangeset).slices():
_xset.update(xset[sli])
xset = _xset
if options.autostep == 'auto':
# Simple implementation of --autostep=auto
# if we have at least 3 nodes, all index should be foldable as a-b/n
xset.autostep = max(3, len(xset))
elif type(options.autostep) is float:
# at least % of nodes should be foldable as a-b/n
autofactor = float(options.autostep)
xset.autostep = int(math.ceil(float(len(xset)) * autofactor))
# user-specified nD-nodeset fold axis
if options.axis:
if not options.axis.startswith('-'):
# axis are 1-indexed in nodeset CLI (0 ignored)
xset.fold_axis = tuple(x-1 for x in RangeSet(options.axis) if x > 0)
else:
# negative axis index (only single number supported)
xset.fold_axis = [int(options.axis)]
fmt = options.output_format # default to '%s'
# Display result according to command choice
if options.expand:
xsubres = lambda x: separator.join((fmt % s for s in x.striter()))
elif options.fold:
# Special case when folding using NodeSet and format is set (#277)
if class_set is NodeSet and fmt != '%s':
# Create a new set after format has been applied to each node
xset = class_set._fromlist1((fmt % xnodestr for xnodestr in xset),
autostep=xset.autostep)
xsubres = lambda x: x
else:
xsubres = lambda x: fmt % x
elif options.regroup:
xsubres = lambda x: fmt % x.regroup(options.groupsource,
noprefix=options.groupbase)
else:
xsubres = lambda x: fmt % len(x)
if not xset or options.maxsplit <= 1 and not options.contiguous:
print xsubres(xset)
else:
if options.contiguous:
xiterator = xset.contiguous()
else:
xiterator = xset.split(options.maxsplit)
for xsubset in xiterator:
print xsubres(xsubset)
def nodeset():
"""script subroutine"""
class_set = NodeSet
usage = "%prog [COMMAND] [OPTIONS] [ns1 [-ixX] ns2|...]"
parser = OptionParser(usage)
parser.install_nodeset_commands()
parser.install_nodeset_operations()
parser.install_nodeset_options()
(options, args) = parser.parse_args()
group_resolver = std_group_resolver()
if options.debug:
group_resolver.set_verbosity(1)
# Check for command presence
cmdcount = int(options.count) + int(options.expand) + \
int(options.fold) + int(bool(options.list)) + \
int(bool(options.listall)) + int(options.regroup) + \
int(options.groupsources)
if not cmdcount:
parser.error("No command specified.")
elif cmdcount > 1:
parser.error("Multiple commands not allowed.")
if options.rangeset:
class_set = RangeSet
if options.all or options.regroup:
if class_set != NodeSet:
parser.error("-a/-r only supported in NodeSet mode")
if options.maxsplit is not None and options.contiguous:
parser.error("incompatible splitting options (split, contiguous)")
if options.maxsplit is None:
options.maxsplit = 1
if options.axis and (not options.fold or options.rangeset):
parser.error("--axis option is only supported when folding nodeset")
if options.groupsource and not options.quiet and class_set == RangeSet:
print >> sys.stderr, "WARNING: option group source \"%s\" ignored" \
% options.groupsource
# We want -s <groupsource> to act as a substition of default groupsource
# (ie. it's not necessary to prefix group names by this group source).
if options.groupsource:
group_resolver.default_source_name = options.groupsource
# The groupsources command simply lists group sources.
if options.groupsources:
if options.quiet:
dispdefault = "" # don't show (default) if quiet is set
else:
dispdefault = " (default)"
for src in group_resolver.sources():
print "%s%s" % (src, dispdefault)
dispdefault = ""
return
autostep = options.autostep
# Do not use autostep for computation when a percentage or the special
# value 'auto' is specified. Real autostep value is set post-process.
if type(autostep) is float or autostep == 'auto':
autostep = None
# Instantiate RangeSet or NodeSet object
xset = class_set(autostep=autostep)
if options.all:
# Include all nodes from external node groups support.
xset.update(NodeSet.fromall()) # uses default_source when set
if not args and not options.all and not (options.list or options.listall):
# No need to specify '-' to read stdin in these cases
process_stdin(xset.update, xset.__class__, autostep)
# Apply first operations (before first non-option)
for nodes in options.and_nodes:
if nodes == '-':
process_stdin(xset.intersection_update, xset.__class__, autostep)
else:
xset.intersection_update(class_set(nodes, autostep=autostep))
for nodes in options.sub_nodes:
if nodes == '-':
process_stdin(xset.difference_update, xset.__class__, autostep)
else:
xset.difference_update(class_set(nodes, autostep=autostep))
for nodes in options.xor_nodes:
if nodes == '-':
process_stdin(xset.symmetric_difference_update, xset.__class__,
autostep)
else:
xset.symmetric_difference_update(
class_set(nodes, autostep=autostep))
# Finish xset computing from args
compute_nodeset(xset, args, autostep)
# The list command has a special handling
if options.list > 0 or options.listall > 0:
return command_list(options, xset, group_resolver)
# Interprete special characters (may raise SyntaxError)
separator = eval('\'%s\'' % options.separator, {"__builtins__": None}, {})
if options.slice_rangeset:
_xset = class_set()
for sli in RangeSet(options.slice_rangeset).slices():
_xset.update(xset[sli])
xset = _xset
if options.autostep == 'auto':
# Simple implementation of --autostep=auto
# if we have at least 3 nodes, all index should be foldable as a-b/n
xset.autostep = max(3, len(xset))
elif type(options.autostep) is float:
# at least % of nodes should be foldable as a-b/n
autofactor = float(options.autostep)
xset.autostep = int(math.ceil(float(len(xset)) * autofactor))
# user-specified nD-nodeset fold axis
if options.axis:
if not options.axis.startswith('-'):
# axis are 1-indexed in nodeset CLI (0 ignored)
xset.fold_axis = tuple(x - 1 for x in RangeSet(options.axis)
if x > 0)
else:
# negative axis index (only single number supported)
xset.fold_axis = [int(options.axis)]
fmt = options.output_format # default to '%s'
# Display result according to command choice
if options.expand:
xsubres = lambda x: separator.join((fmt % s for s in x.striter()))
elif options.fold:
# Special case when folding using NodeSet and format is set (#277)
if class_set is NodeSet and fmt != '%s':
# Create a new set after format has been applied to each node
xset = class_set._fromlist1((fmt % xnodestr for xnodestr in xset),
autostep=xset.autostep)
xsubres = lambda x: x
else:
xsubres = lambda x: fmt % x
elif options.regroup:
xsubres = lambda x: fmt % x.regroup(options.groupsource,
noprefix=options.groupbase)
else:
xsubres = lambda x: fmt % len(x)
if not xset or options.maxsplit <= 1 and not options.contiguous:
print xsubres(xset)
else:
if options.contiguous:
xiterator = xset.contiguous()
else:
xiterator = xset.split(options.maxsplit)
for xsubset in xiterator:
print xsubres(xsubset)
def nodeset():
"""script subroutine"""
class_set = NodeSet
usage = "%prog [COMMAND] [OPTIONS] [ns1 [-ixX] ns2|...]"
parser = OptionParser(usage)
parser.install_nodeset_commands()
parser.install_nodeset_operations()
parser.install_nodeset_options()
(options, args) = parser.parse_args()
group_resolver = std_group_resolver()
if options.debug:
group_resolver.set_verbosity(1)
# Check for command presence
cmdcount = int(options.count) + int(options.expand) + \
int(options.fold) + int(bool(options.list)) + \
int(options.regroup) + int(options.groupsources)
if not cmdcount:
parser.error("No command specified.")
elif cmdcount > 1:
parser.error("Multiple commands not allowed.")
if options.rangeset:
class_set = RangeSet
if options.all or options.regroup:
if class_set != NodeSet:
parser.error("-a/-r only supported in NodeSet mode")
if options.maxsplit is not None and options.contiguous:
parser.error("incompatible splitting options (split, contiguous)")
if options.maxsplit is None:
options.maxsplit = 1
if options.groupsource and not options.quiet and class_set == RangeSet:
print >> sys.stderr, "WARNING: option group source \"%s\" ignored" \
% options.groupsource
# We want -s <groupsource> to act as a substition of default groupsource
# (ie. it's not necessary to prefix group names by this group source).
if options.groupsource:
group_resolver.default_source_name = options.groupsource
# The groupsources command simply lists group sources.
if options.groupsources:
if options.quiet:
dispdefault = "" # don't show (default) if quiet is set
else:
dispdefault = " (default)"
for src in group_resolver.sources():
print "%s%s" % (src, dispdefault)
dispdefault = ""
return
# Instantiate RangeSet or NodeSet object
xset = class_set(autostep=options.autostep)
if options.all:
# Include all nodes from external node groups support.
xset.update(NodeSet.fromall()) # uses default_source when set
if not args and not options.all and not options.list:
# No need to specify '-' to read stdin in these cases
process_stdin(xset.update, xset.__class__, options.autostep)
# Apply first operations (before first non-option)
for nodes in options.and_nodes:
if nodes == '-':
process_stdin(xset.intersection_update, xset.__class__,
options.autostep)
else:
xset.intersection_update(
class_set(nodes, autostep=options.autostep))
for nodes in options.sub_nodes:
if nodes == '-':
process_stdin(xset.difference_update, xset.__class__,
options.autostep)
else:
xset.difference_update(class_set(nodes, autostep=options.autostep))
for nodes in options.xor_nodes:
if nodes == '-':
process_stdin(xset.symmetric_difference_update, xset.__class__,
options.autostep)
else:
xset.symmetric_difference_update(class_set(nodes, \
autostep=options.autostep))
# Finish xset computing from args
compute_nodeset(xset, args, options.autostep)
# The list command has a special handling
if options.list > 0:
return command_list(options, xset)
# Interprete special characters (may raise SyntaxError)
separator = eval('\'%s\'' % options.separator, {"__builtins__": None}, {})
if options.slice_rangeset:
_xset = class_set()
for sli in RangeSet(options.slice_rangeset).slices():
_xset.update(xset[sli])
xset = _xset
format = options.output_format # default to '%s'
# Display result according to command choice
if options.expand:
xsubres = lambda x: separator.join((format % s for s in x.striter()))
elif options.fold:
xsubres = lambda x: format % x
elif options.regroup:
xsubres = lambda x: format % x.regroup(options.groupsource,
noprefix=options.groupbase)
else:
xsubres = lambda x: format % len(x)
if not xset or options.maxsplit <= 1 and not options.contiguous:
print xsubres(xset)
else:
if options.contiguous:
xiterator = xset.contiguous()
else:
xiterator = xset.split(options.maxsplit)
for xsubset in xiterator:
print xsubres(xsubset)
def nodeset():
"""script subroutine"""
class_set = NodeSet
usage = "%prog [COMMAND] [OPTIONS] [ns1 [-ixX] ns2|...]"
parser = OptionParser(usage)
parser.install_nodeset_commands()
parser.install_nodeset_operations()
parser.install_nodeset_options()
(options, args) = parser.parse_args()
group_resolver = std_group_resolver()
if options.debug:
group_resolver.set_verbosity(1)
# Check for command presence
cmdcount = int(options.count) + int(options.expand) + \
int(options.fold) + int(bool(options.list)) + \
int(options.regroup) + int(options.groupsources)
if not cmdcount:
parser.error("No command specified.")
elif cmdcount > 1:
parser.error("Multiple commands not allowed.")
if options.rangeset:
class_set = RangeSet
if options.all or options.regroup:
if class_set != NodeSet:
parser.error("-a/-r only supported in NodeSet mode")
if options.maxsplit is not None and options.contiguous:
parser.error("incompatible splitting options (split, contiguous)")
if options.maxsplit is None:
options.maxsplit = 1
if options.groupsource and not options.quiet and class_set == RangeSet:
print >> sys.stderr, "WARNING: option group source \"%s\" ignored" \
% options.groupsource
# We want -s <groupsource> to act as a substition of default groupsource
# (ie. it's not necessary to prefix group names by this group source).
if options.groupsource:
group_resolver.default_source_name = options.groupsource
# The groupsources command simply lists group sources.
if options.groupsources:
if options.quiet:
dispdefault = "" # don't show (default) if quiet is set
else:
dispdefault = " (default)"
for src in group_resolver.sources():
print "%s%s" % (src, dispdefault)
dispdefault = ""
return
# Instantiate RangeSet or NodeSet object
xset = class_set(autostep=options.autostep)
if options.all:
# Include all nodes from external node groups support.
xset.update(NodeSet.fromall()) # uses default_source when set
if not args and not options.all and not options.list:
# No need to specify '-' to read stdin in these cases
process_stdin(xset.update, xset.__class__, options.autostep)
# Apply first operations (before first non-option)
for nodes in options.and_nodes:
if nodes == '-':
process_stdin(xset.intersection_update, xset.__class__,
options.autostep)
else:
xset.intersection_update(class_set(nodes,
autostep=options.autostep))
for nodes in options.sub_nodes:
if nodes == '-':
process_stdin(xset.difference_update, xset.__class__,
options.autostep)
else:
xset.difference_update(class_set(nodes, autostep=options.autostep))
for nodes in options.xor_nodes:
if nodes == '-':
process_stdin(xset.symmetric_difference_update, xset.__class__,
options.autostep)
else:
xset.symmetric_difference_update(class_set(nodes, \
autostep=options.autostep))
# Finish xset computing from args
compute_nodeset(xset, args, options.autostep)
# The list command has a special handling
if options.list > 0:
return command_list(options, xset)
# Interprete special characters (may raise SyntaxError)
separator = eval('\'%s\'' % options.separator, {"__builtins__":None}, {})
if options.slice_rangeset:
_xset = class_set()
for sli in RangeSet(options.slice_rangeset).slices():
_xset.update(xset[sli])
xset = _xset
format = options.output_format # default to '%s'
# Display result according to command choice
if options.expand:
xsubres = lambda x: separator.join((format % s for s in x.striter()))
elif options.fold:
xsubres = lambda x: format % x
elif options.regroup:
xsubres = lambda x: format % x.regroup(options.groupsource,
noprefix=options.groupbase)
else:
xsubres = lambda x: format % len(x)
if not xset or options.maxsplit <= 1 and not options.contiguous:
print xsubres(xset)
else:
if options.contiguous:
xiterator = xset.contiguous()
else:
xiterator = xset.split(options.maxsplit)
for xsubset in xiterator:
print xsubres(xsubset)