"""Raised when NodeSet parsing cannot be done properly."""

def __init__(self, part, msg):

if part:

msg = "%s: \"%s\"" % (msg, part)

NodeSetError.__init__(self, msg)

# faulty part; this allows you to target the error

"""

def __init__(self, pattern=None, rangeset=None, copy_rangeset=True,

autostep=None, fold_axis=None):

"""New NodeSetBase object initializer"""

self._autostep = autostep

self._length = 0

self._patterns = {}

self.fold_axis = fold_axis #: iterable over nD 0-indexed axis

if self.fold_axis is None and DEFAULTS.fold_axis:

self.fold_axis = DEFAULTS.fold_axis # non-empty tuple

if pattern:

self._add(pattern, rangeset, copy_rangeset)

elif rangeset:

raise ValueError("missing pattern")

def get_autostep(self):

"""Get autostep value (property)"""

return self._autostep

def set_autostep(self, val):

"""Set autostep value (property)"""

if val is None:

self._autostep = None

else:

# Work around the pickling issue of sys.maxint (+inf) in py2.4

self._autostep = min(int(val), AUTOSTEP_DISABLED)

# Update our RangeSet/RangeSetND objects

for pat, rset in self._patterns.items():

if rset:

rset.autostep = self._autostep

autostep = property(get_autostep, set_autostep)

def _iter(self):

"""Iterator on internal item tuples

for pat, rset in sorted(self._patterns.items()):

if rset:

autostep = rset.autostep

if rset.dim() == 1:

assert isinstance(rset, RangeSet)

for idx in rset:

yield pat, (idx,), autostep

else:

for rvec in rset:

yield pat, rvec, autostep

else:

yield pat, None, None

def _iterbase(self):

"""Iterator on single, one-item NodeSetBase objects."""

for pat, ivec, autostep in self._iter():

rset = None # 'no node index' by default

if ivec is not None:

assert len(ivec) > 0

if len(ivec) == 1:

rset = RangeSet.fromone(ivec[0], autostep)

else:

rset = RangeSetND([ivec], autostep)

yield NodeSetBase(pat, rset)

def __iter__(self):

"""Iterator on single nodes as string."""

# Does not call self._iterbase() + str() for better performance.

for pat, ivec, _ in self._iter():

if ivec is not None:

yield pat % ivec

else:

yield pat % ()

# define striter() alias for convenience (to match RangeSet.striter())

striter = __iter__

# define nsiter() as an object-based iterator that could be used for

# __iter__() in the future...

def nsiter(self):

"""Object-based NodeSet iterator on single nodes."""

for pat, ivec, autostep in self._iter():

nodeset = self.__class__()

if ivec is not None:

if len(ivec) == 1:

nodeset._add_new(pat, RangeSet.fromone(ivec[0]))

else:

nodeset._add_new(pat, RangeSetND([ivec], autostep))

else:

nodeset._add_new(pat, None)

yield nodeset

def contiguous(self):

"""Object-based NodeSet iterator on contiguous node sets.

for pat, rangeset in sorted(self._patterns.items()):

if rangeset:

for cont_rset in rangeset.contiguous():

nodeset = self.__class__()

nodeset._add_new(pat, cont_rset)

yield nodeset

else:

nodeset = self.__class__()

nodeset._add_new(pat, None)

yield nodeset

def __len__(self):

"""Get the number of nodes in NodeSet."""

cnt = 0

for rangeset in self._patterns.values():

if rangeset:

cnt += len(rangeset)

else:

cnt += 1

return cnt

def _iter_nd_pat(self, pat, rset):

"""

try:

dimcnt = rset.dim()

if self.fold_axis is None:

# fold along all axis (default)

fold_axis = range(dimcnt)

else:

# set of user-provided fold axis (support negative numbers)

fold_axis = [int(x) % dimcnt for x in self.fold_axis

if -dimcnt <= int(x) < dimcnt]

except (TypeError, ValueError) as exc:

raise NodeSetParseError("fold_axis=%s" % self.fold_axis, exc)

for rgvec in rset.vectors():

rgnargs = [] # list of str rangeset args

for axis, rangeset in enumerate(rgvec):

# build an iterator over rangeset strings to add

if len(rangeset) > 1:

if axis not in fold_axis: # expand

rgstrit = rangeset.striter()

else:

rgstrit = ["[%s]" % rangeset]

else:

rgstrit = [str(rangeset)]

# aggregate/expand along previous computed axis...

t_rgnargs = []

for rgstr in rgstrit: # 1-time when not expanding

if not rgnargs:

t_rgnargs.append([rgstr])

else:

for rga in rgnargs:

t_rgnargs.append(rga + [rgstr])

rgnargs = t_rgnargs

# get nodeset patterns formatted with range strings

for rgargs in rgnargs:

yield pat % tuple(rgargs)

def __str__(self):

"""Get ranges-based pattern of node list."""

results = []

try:

for pat, rset in sorted(self._patterns.items()):

if not rset:

results.append(pat % ())

elif rset.dim() == 1:

# check if allowed to fold even for 1D pattern

if self.fold_axis is None or \

list(x for x in self.fold_axis if -1 <= int(x) < 1):

rgs = str(rset)

cnt = len(rset)

if cnt > 1:

rgs = "[%s]" % rgs

results.append(pat % rgs)

else:

results.extend((pat % rgs for rgs in rset.striter()))

elif rset.dim() > 1:

results.extend(self._iter_nd_pat(pat, rset))

except TypeError:

raise NodeSetParseError(pat, "Internal error: node pattern and "

"ranges mismatch")

return ",".join(results)

def copy(self):

"""Return a shallow copy."""

cpy = self.__class__()

cpy.fold_axis = self.fold_axis

cpy._autostep = self._autostep

cpy._length = self._length

dic = {}

for pat, rangeset in self._patterns.items():

if rangeset is None:

dic[pat] = None

else:

dic[pat] = rangeset.copy()

cpy._patterns = dic

return cpy

def __contains__(self, other):

"""Is node contained in NodeSet ?"""

return self.issuperset(other)

def _binary_sanity_check(self, other):

# check that the other argument to a binary operation is also

# a NodeSet, raising a TypeError otherwise.

if not isinstance(other, NodeSetBase):

raise TypeError("Binary operation only permitted between "

"NodeSetBase")

def issubset(self, other):

"""Report whether another nodeset contains this nodeset."""

self._binary_sanity_check(other)

return other.issuperset(self)

def issuperset(self, other):

"""Report whether this nodeset contains another nodeset."""

self._binary_sanity_check(other)

status = True

for pat, erangeset in other._patterns.items():

rangeset = self._patterns.get(pat)

if rangeset:

status = rangeset.issuperset(erangeset)

else:

# might be an unnumbered node (key in dict but no value)

status = pat in self._patterns

if not status:

break

return status

def __eq__(self, other):

"""NodeSet equality comparison."""

# See comment for for RangeSet.__eq__()

if not isinstance(other, NodeSetBase):

return NotImplemented

return len(self) == len(other) and self.issuperset(other)

# inequality comparisons using the is-subset relation

__le__ = issubset

__ge__ = issuperset

def __lt__(self, other):

"""x.__lt__(y) <==> x<y"""

self._binary_sanity_check(other)

return len(self) < len(other) and self.issubset(other)

def __gt__(self, other):

"""x.__gt__(y) <==> x>y"""

self._binary_sanity_check(other)

return len(self) > len(other) and self.issuperset(other)

def _extractslice(self, index):

"""Private utility function: extract slice parameters from slice object

length = len(self)

if index.start is None:

sl_start = 0

elif index.start < 0:

sl_start = max(0, length + index.start)

else:

sl_start = index.start

if index.stop is None:

sl_stop = sys.maxsize

elif index.stop < 0:

sl_stop = max(0, length + index.stop)

else:

sl_stop = index.stop

if index.step is None:

sl_step = 1

elif index.step < 0:

# We support negative step slicing with no start/stop, ie. r[::-n].

if index.start is not None or index.stop is not None:

raise IndexError("illegal start and stop when negative step "

"is used")

# As RangeSet elements are ordered internally, adjust sl_start

# to fake backward stepping in case of negative slice step.

stepmod = (length + -index.step - 1) % -index.step

if stepmod > 0:

sl_start += stepmod

sl_step = -index.step

else:

sl_step = index.step

if not isinstance(sl_start, int) or not isinstance(sl_stop, int) \

or not isinstance(sl_step, int):

raise TypeError("slice indices must be integers")

return sl_start, sl_stop, sl_step

def __getitem__(self, index):

"""Return the node at specified index or a subnodeset when a slice is

if isinstance(index, slice):

inst = NodeSetBase()

sl_start, sl_stop, sl_step = self._extractslice(index)

sl_next = sl_start

if sl_stop <= sl_next:

return inst

length = 0

for pat, rangeset in sorted(self._patterns.items()):

if rangeset:

cnt = len(rangeset)

offset = sl_next - length

if offset < cnt:

num = min(sl_stop - sl_next, cnt - offset)

inst._add(pat, rangeset[offset:offset + num:sl_step])

else:

#skip until sl_next is reached

length += cnt

continue

else:

cnt = num = 1

if sl_next > length:

length += cnt

continue

inst._add(pat, None)

# adjust sl_next...

sl_next += num

if (sl_next - sl_start) % sl_step:

sl_next = sl_start + \

((sl_next - sl_start)/sl_step + 1) * sl_step

if sl_next >= sl_stop:

break

length += cnt

return inst

elif isinstance(index, int):

if index < 0:

length = len(self)

if index >= -length:

index = length + index # - -index

else:

raise IndexError("%d out of range" % index)

length = 0

for pat, rangeset in sorted(self._patterns.items()):

if rangeset:

cnt = len(rangeset)

if index < length + cnt:

# return a subrangeset of size 1 to manage padding

if rangeset.dim() == 1:

return pat % rangeset[index-length:index-length+1]

else:

sub = rangeset[index-length:index-length+1]

for rgvec in sub.vectors():

return pat % (tuple(rgvec))

else:

cnt = 1

if index == length:

return pat

length += cnt

raise IndexError("%d out of range" % index)

else:

raise TypeError("NodeSet indices must be integers")

def _rangeset_index(self, rangeset, orangeset):

"""Return the position of the single index held by `orangeset`

# unnumbered node (eg. 'server'): both must have no index

if rangeset is None or orangeset is None:

return 0 if rangeset is None and orangeset is None else None

try:

if isinstance(orangeset, RangeSetND):

# nD: orangeset holds a single index vector

return rangeset.index(next(iter(orangeset)))

# 1D: orangeset holds a single (possibly zero-padded) index

return rangeset.index(next(orangeset.striter()))

except ValueError:

return None

def index(self, other, start=0, stop=None):

"""Return the zero-based index in the nodeset of the node `other`.

self._binary_sanity_check(other)

if len(other) != 1:

raise ValueError("index() argument must be a single node")

# extract the single (pattern, rangeset) of the searched node

opat, orangeset = list(other._patterns.items())[0]

# walk patterns in iteration order, summing sizes until we reach the

# pattern of the searched node

found = None

base = 0

for pat, rangeset in sorted(self._patterns.items()):

if pat == opat:

offset = self._rangeset_index(rangeset, orangeset)

if offset is not None:

found = base + offset

break

if rangeset:

base += len(rangeset)

else:

base += 1

if found is None:

raise ValueError("'%s' is not in nodeset" % other)

# honor optional start/stop search window (list.index() semantics)

if start != 0 or stop is not None:

length = len(self)

if start < 0:

start = max(0, length + start)

if stop is None:

stop = length

elif stop < 0:

stop = max(0, length + stop)

if not start <= found < stop:

raise ValueError("'%s' is not in nodeset" % other)

return found

def _add_new(self, pat, rangeset):

"""Add nodes from a (pat, rangeset) tuple.

assert pat not in self._patterns

self._patterns[pat] = rangeset

def _add(self, pat, rangeset, copy_rangeset=True):

"""Add nodes from a (pat, rangeset) tuple.

if pat in self._patterns:

# existing pattern: get RangeSet or RangeSetND entry...

pat_e = self._patterns[pat]

# sanity checks

if (pat_e is None) is not (rangeset is None):

raise NodeSetError("Invalid operation")

# entry may exist but set to None (single node)

if pat_e:

pat_e.update(rangeset)

else:

# new pattern...

if rangeset and copy_rangeset:

# default is to inherit rangeset autostep value

rangeset = rangeset.copy()

# but if set, self._autostep does override it

if self._autostep is not None:

# works with rangeset 1D or nD

rangeset.autostep = self._autostep

self._add_new(pat, rangeset)

def union(self, other):

"""

self_copy = self.copy()

self_copy.update(other)

return self_copy

def __or__(self, other):

"""

if not isinstance(other, NodeSetBase):

return NotImplemented

return self.union(other)

def add(self, other):

"""

self.update(other)

def update(self, other):

"""

for pat, rangeset in other._patterns.items():

self._add(pat, rangeset)

def updaten(self, others):

"""

for other in others:

self.update(other)

def clear(self):

"""

self._patterns.clear()

def __ior__(self, other):

"""

self._binary_sanity_check(other)

self.update(other)

return self

def intersection(self, other):

"""

self_copy = self.copy()

self_copy.intersection_update(other)

return self_copy

def __and__(self, other):

"""

if not isinstance(other, NodeSet):

return NotImplemented

return self.intersection(other)

def intersection_update(self, other):

"""

if other is self:

return

tmp_ns = NodeSetBase()

for pat, irangeset in other._patterns.items():

rangeset = self._patterns.get(pat)

if rangeset:

irset = rangeset.intersection(irangeset)

# ignore pattern if empty rangeset

if len(irset) > 0:

tmp_ns._add(pat, irset, copy_rangeset=False)

elif not irangeset and pat in self._patterns:

# intersect two nodes with no rangeset

tmp_ns._add(pat, None)

# Substitute

self._patterns = tmp_ns._patterns

def __iand__(self, other):

"""

self._binary_sanity_check(other)

self.intersection_update(other)

return self

def difference(self, other):

"""

self_copy = self.copy()

self_copy.difference_update(other)

return self_copy

def __sub__(self, other):

"""

if not isinstance(other, NodeSetBase):

return NotImplemented

return self.difference(other)

def difference_update(self, other, strict=False):

"""

# the purge of each empty pattern is done afterward to allow self = ns

purge_patterns = []

# iterate first over exclude nodeset rangesets which is usually smaller

for pat, erangeset in other._patterns.items():

# if pattern is found, deal with it

rangeset = self._patterns.get(pat)

if rangeset:

# sub rangeset, raise KeyError if not found

rangeset.difference_update(erangeset, strict)

# check if no range left and add pattern to purge list

if len(rangeset) == 0:

purge_patterns.append(pat)

else:

# unnumbered node exclusion

if pat in self._patterns:

purge_patterns.append(pat)

elif strict:

raise KeyError(pat)

for pat in purge_patterns:

del self._patterns[pat]

def __isub__(self, other):

"""

self._binary_sanity_check(other)

self.difference_update(other)

return self

def remove(self, elem):

"""

self.difference_update(elem, True)

def symmetric_difference(self, other):

"""

self_copy = self.copy()

self_copy.symmetric_difference_update(other)

return self_copy

def __xor__(self, other):

"""

if not isinstance(other, NodeSet):

return NotImplemented

return self.symmetric_difference(other)

def symmetric_difference_update(self, other):

"""

purge_patterns = []

# iterate over our rangesets

for pat, rangeset in self._patterns.items():

brangeset = other._patterns.get(pat)

if brangeset:

rangeset.symmetric_difference_update(brangeset)

else:

if pat in other._patterns:

purge_patterns.append(pat)

# iterate over other's rangesets

for pat, brangeset in other._patterns.items():

rangeset = self._patterns.get(pat)

if not rangeset and not pat in self._patterns:

self._add(pat, brangeset)

# check for patterns cleanup

for pat, rangeset in self._patterns.items():

if rangeset is not None and len(rangeset) == 0:

purge_patterns.append(pat)

# cleanup

for pat in purge_patterns:

del self._patterns[pat]

def __ixor__(self, other):

"""

self._binary_sanity_check(other)

self.symmetric_difference_update(other)

"""

"""

if len(rsets) > 1:

return RangeSetND([rsets], None, autostep, copy_rangeset=False)

elif len(rsets) == 1:

"""

OP_CODES = {',': 'update',

'!': 'difference_update',

'&': 'intersection_update',

'^': 'symmetric_difference_update'}

OP_CODES_PAT = '[%s]' % re.escape(''.join(OP_CODES.keys()))

BRACKET_OPEN = '['

BRACKET_CLOSE = ']'

def __init__(self, group_resolver, node_wildcard_enable=True):

"""

self.group_resolver = group_resolver

self.base_node_re = re.compile(r"(\D*)(\d*)")

self.node_wc = node_wildcard_enable # node wildcard support

def parse(self, nsobj, autostep):

"""

# passing None is supported

if nsobj is None:

return NodeSetBase()

# is nsobj a NodeSetBase instance?

if isinstance(nsobj, NodeSetBase):

return nsobj

# or is nsobj a string?

if isinstance(nsobj, basestring):

try:

return self.parse_string(str(nsobj), autostep)

except (NodeUtils.GroupSourceQueryFailed, RuntimeError) as exc:

raise NodeSetParseError(nsobj, str(exc))

raise TypeError("Unsupported NodeSet input %s" % type(nsobj))

def parse_string(self, nsstr, autostep, namespace=None):

"""Parse provided string in optional namespace.

alln_cache = None # used to compute 'all nodes' only once

nodeset = NodeSetBase()

nsstr = _strip_escape(nsstr)

for opc, pat, rgnd in self._scan_string(nsstr, autostep):

# Parser main debugging:

#print "OPC %s PAT %s RANGESETS %s" % (opc, pat, rgnd)

if self.group_resolver and pat[0] == '@':

ns_group = NodeSetBase()

for nodegroup in NodeSetBase(pat, rgnd):

# parse/expand nodes group: get group string and namespace

ns_str_ext, ns_nsp_ext = self.parse_group_string(nodegroup,

namespace)

if ns_str_ext: # may still contain groups

# recursively parse and aggregate result

ns_group.update(self.parse_string(ns_str_ext,

autostep,

ns_nsp_ext))

# perform operation

getattr(nodeset, opc)(ns_group)

elif self.group_resolver and self.node_wc and ('*' in pat or

'?' in pat):

# We support ranges with wildcard mask by testing all nodes

# against each expanded mask (wcmasks).

wcmasks = (str(wcn) for wcn in NodeSetBase(pat, rgnd, False))

# Our reference set is 'all nodes', we need to build it from

# NodeSetBase to iterate over each individual node.

if alln_cache is None:

self.node_wc = False # avoid infinite recursion

try:

nsb = NodeSetBase()

for res in self.all_nodes(namespace):

nsb.update(self.parse_string(res, autostep,

namespace))

alln_cache = set(str(node) for node in nsb)

finally:

self.node_wc = True

alln = alln_cache.copy()

# A wildcarded nodeset can be seen as a single nodeset, so we

# compute the union of nodes matching the wildcard mask(s) and

# use the resulting NodeSetBase object as argument of the next

# operation (opc).

wcns = NodeSetBase()

for wcmask in wcmasks:

# Expand nodes matching any of the wildcard mask

for node in fnmatch.filter(alln, wcmask):

alln.remove(node) # remove matching node for next iter

wcp, wcr = self._scan_string_single(node, autostep)

wcrgnd = _rsets4nsb(wcr, autostep)

wcns.update(NodeSetBase(wcp, wcrgnd, False))

getattr(nodeset, opc)(wcns)

else:

getattr(nodeset, opc)(NodeSetBase(pat, rgnd, False))

return nodeset

def parse_string_single(self, nsstr, autostep):

"""Parse provided string and return a NodeSetBase object."""

pat, rangesets = self._scan_string_single(_strip_escape(nsstr),

autostep)

if len(rangesets) > 1:

rgobj = RangeSetND([rangesets], None, autostep, copy_rangeset=False)

elif len(rangesets) == 1:

rgobj = rangesets[0]

else: # non-indexed nodename

rgobj = None

return NodeSetBase(pat, rgobj, False)

def parse_group(self, group, namespace=None, autostep=None):

"""Parse provided single group name (without @ prefix)."""

assert self.group_resolver is not None

nodestr = self.group_resolver.group_nodes(group, namespace)

return self.parse(",".join(nodestr), autostep)

def parse_group_string(self, nodegroup, namespace=None):

"""Parse provided raw nodegroup string in optional namespace.

assert nodegroup[0] == '@'

assert self.group_resolver is not None

grpstr = group = nodegroup[1:]

if grpstr.find(':') >= 0:

# specified namespace does always override

namespace, group = grpstr.split(':', 1)

if group == '*': # @* or @source:* magic

reslist = self.all_nodes(namespace)

elif group.startswith('@'): # @@source group name list

reslist = self.grouplist(grpstr[1:])

else:

reslist = self.group_resolver.group_nodes(group, namespace)

return ','.join(reslist), namespace

def grouplist(self, namespace=None):

"""