From 4247fb899526f02f6382d9c8ae8bd691b9b1b861 Mon Sep 17 00:00:00 2001 From: Brian Harring Date: Tue, 16 Aug 2005 00:19:57 +0000 Subject: restriction subsystem slight redesign. bugs probably exist in force_(Fail,True), although containmentmatch appears to work (use deps are working now) packages is package level restrictions values is value level restrictions; package restrictions gank the attributes, and hand them off to value restrictions (effectively) collapsed is package level. boolean is a base of boolean logic classes, properly support the full potential combinations NAND and OR have (that sucked). same with ContainmentMatch --- portage/restrictions/boolean.py | 411 +++++++++++++++++++++++++++++++++ portage/restrictions/packages.py | 140 +++++++++++ portage/restrictions/restrictionSet.py | 167 -------------- portage/restrictions/values.py | 286 +++++++++++++++++++++++ 4 files changed, 837 insertions(+), 167 deletions(-) create mode 100644 portage/restrictions/boolean.py create mode 100644 portage/restrictions/packages.py delete mode 100644 portage/restrictions/restrictionSet.py create mode 100644 portage/restrictions/values.py diff --git a/portage/restrictions/boolean.py b/portage/restrictions/boolean.py new file mode 100644 index 0000000..05bd820 --- /dev/null +++ b/portage/restrictions/boolean.py @@ -0,0 +1,411 @@ +# Copyright: 2005 Gentoo Foundation +# Author(s): Brian Harring (ferringb@gentoo.org) +# License: GPL2 +# $Header: /local/data/ulm/cvs/history/var/cvsroot/gentoo-src/portage/portage/restrictions/boolean.py,v 1.1 2005/08/16 00:19:57 ferringb Exp $ + +""" +This module provides classes that can be used to combine arbitrary collections of restrictions in AND, NAND, OR, NOR, XOR, XNOR +style operations. +""" + +from itertools import imap, islice +from portage.util.iterate import enumerate + +__all__ = ("AndRestriction", "OrRestriction", "XorRestriction") +import restriction + +class base(restriction.base): + __slots__ = tuple(["restrictions"] + restriction.base.__slots__) + required_base = None + + def __init__(self, *restrictions, **kwds): + """Optionally hand in (positionally) restrictions to use as the basis of this restriction + finalize=False, set it to True to notify this instance to internally finalize itself (no way to reverse it yet) + negate=False, controls whether matching results are negated + """ + if "finalize" in kwds: + finalize = kwds["finalize"] + del kwds["finalize"] + else: + finalize = False + super(base, self).__init__(**kwds) + for x in restrictions: + if not isinstance(x, restriction.base): + #bad monkey. + raise TypeError, x + + if finalize: + self.restrictions = tuple(restrictions) + else: + self.restrictions = list(restrictions) + + + def add_restriction(self, *new_restrictions): + """add restriction(s), must be isinstance of required_base + """ + if len(new_restrictions) == 0: + raise TypeError("need at least one restriction handed in") + for r in new_restrictions: + if not isinstance(r, self.required_base): + raise TypeError("instance '%s' isn't a derivative '%s'" % (r, self.required_base)) + + self.restrictions.extend(new_restrictions) + + def finalize(self): + self.restrictions = tuple(self.restrictions) + + def total_len(self): return sum(imap(lambda x: x.total_len(), self.restrictions)) + 1 + + def __len__(self): return len(self.restrictions) + + def __iter__(self): return iter(self.restrictions) + + def match(self, action, *vals): + raise NotImplementedError + + force_False, force_True = match, match + + def __getitem__(self, key): + return self.restrictions[key] + + +# this beast, handles N^2 permutations. convert to stack based. +def iterative_quad_toggling(pkg, pvals, restrictions, starting, end, truths, filter, desired_false=None, desired_true=None, kill_switch=None): + if desired_false == None: + desired_false = lambda r, a:r.force_False(*a) + if desired_true == None: + desired_true = lambda r, a:r.force_True(*a) + +# import pdb;pdb.set_trace() + reset = True + if starting == 0: + if filter(truths): + yield True + for index, rest in enumerate(restrictions, starting, end): + if reset: + entry = pkg.changes_count() + reset = False + if truths[index]: + if desired_false(rest, pvals): + reset = True + t = truths[:] + t[index] = False + if filter(t): + yield True + for x in iterative_quad_toggling(pkg, pvals, restrictions, index + 1, end, t, filter, + desired_false=desired_false, desired_true=desired_true, kill_switch=kill_switch): +# import pdb;pdb.set_trace() + yield True + reset = True + else: + if kill_switch != None and kill_switch(truths, index): + return + else: + if desired_true(rest, pvals): + reset = True + t = truths[:] + t[index] = True + if filter(t): + yield True + for x in iterative_quad_toggling(pkg, pvals, restrictions, index + 1, end, t, filter, + desired_false=desired_false, desired_true=desired_true): +# import pdb;pdb.set_trace() + yield True + reset = True + elif index == end: + if filter(truths): +# import pdb;pdb.set_trace() + yield True + else: + if kill_switch != None and kill_switch(truths, index): + return + + if reset: + pkg.rollback(entry) + + +class AndRestriction(base): + """Boolean AND grouping of restrictions. negation is a NAND""" + __slots__ = tuple(base.__slots__) + + def match(self, vals): + if self.negate: + # 1|1 == 0, 1|0 == 0|1 == 0|0 == 1 + missed = False + for rest in self.restrictions: + if not rest.match(vals): + missed = True + elif missed: + return True + return False + for rest in self.restrictions: + if not rest.match(vals): + return False + return True + + def force_True(self, pkg, *vals): + pvals = [pkg] + pvals.extend(vals) + entry_point = pkg.changes_count() + # get the simple one out of the way first. + if not self.negate: + for r in self.restrictions: + if not r.force_True(*pvals): + pkg.rollback(entry_point) + return + yield True + return + + # , NAND logic, len(restrictions)**2 potential solutions. + # 0|0 == 0, 0|1 == 1|0 == 0|0 == 1. + # XXX this is quadratic. patches welcome to dodge the requirement to push through all potential + # truths. + truths = [r.match(*pvals) for r in self.restrictions] + def filter(truths): + return False in truths + + for x in iterative_quad_toggling(pkg, pvals, self.restrictions, 0, len(self.restrictions), truths, filter): + yield True + + def force_False(self, pkg, *vals): + pvals = [pkg] + pvals.extend(vals) + entry_point = pkg.changes_count() + # get the simple one out of the way first. + if self.negate: + for r in self.restrictions: + if not r.force_True(*pvals): + pkg.rollback(entry_point) + return + yield True + return + + # , NAND logic, (len(restrictions)^2)-1 potential solutions. + # 1|1 == 0, 0|1 == 1|0 == 0|0 == 1. + # XXX this is quadratic. patches welcome to dodge the requirement to push through all potential + # truths. + truths = [r.match(*pvals) for r in self.restrictions] + def filter(truths): + return False in truths + for x in iterative_quad_toggling(pkg, pvals, self.restrictions, 0, len(self.restrictions), truths, filter): + yield True + + def __str__(self): + if self.negate: return "not ( %s )" % " && ".join(imap(str, self.restrictions)) + return "( %s )" % " && ".join(imap(str, self.restrictions)) + + +class OrRestriction(base): + """Boolean OR grouping of restrictions.""" + __slots__ = base.__slots__ + + def match(self, vals): + if self.negate: + # 1|1 == 1|0 == 0|1 == 0, 0|0 == 1 + for rest in self.restrictions: + if rest.match(vals): + return + return True + for rest in self.restrictions: + if rest.match(vals): + return True + return False + + def force_True(self, pkg, *vals): + pvals = [pkg] + pvals.extend(vals) + entry_point = pkg.changes_count() + # get the simple one out of the way first. + if self.negate: + for r in self.restrictions: + if not r.force_False(*pvals): + pkg.rollback(entry_point) + return + yield True + return + + # , OR logic, len(restrictions)**2-1 potential solutions. + # 0|0 == 0, 0|1 == 1|0 == 1|1 == 1. + # XXX this is quadratic. patches welcome to dodge the requirement to push through all potential + # truths. + truths = [r.match(*pvals) for r in self.restrictions] + def filter(truths): + return True in truths + for x in iterative_quad_toggling(pkg, pvals, self.restrictions, 0, len(self.restrictions), truths, filter): + yield True + + + def force_False(self, pkg, *vals): + pvals = [pkg] + pvals.extend(vals) + entry_point = pkg.changes_count() + # get the simple one out of the way first. + if not self.negate: + for r in self.restrictions: + if not r.force_False(*vals): + pkg.rollback(entry_point) + return + yield True + return + + # , OR logic, (len(restrictions)**2)-1 potential solutions. + # 0|0 == 0, 0|1 == 1|0 == 1|1 == 1. + # XXX this is quadratic. patches welcome to dodge the requirement to push through all potential + # truths. + truths = [r.match(*pvals) for r in self.restrictions] + def filter(truths): + return True in truths + for x in iterative_quad_toggling(pkg, pvals, self.restrictions, 0, len(self.restrictions), truths, filter): + yield True + + + def __str__(self): + if self.negate: return "not ( %s )" % " || ".join(imap(str, self.restrictions)) + return "( %s )" % " || ".join(imap(str, self.restrictions)) + + +class XorRestriction(base): + """Boolean XOR grouping of restrictions.""" + __slots__ = tuple(base.__slots__) + + def match(self, vals): + if len(self.restrictions) == 0: + return not self.negate + + if self.negate: + # 1|1 == 0|0 == 1, 0|1 == 1|0 == 0 + armed = self.restrictions[0].match(*vals) + for rest in islice(self.restrictions, 1, len(self.restrictions)): + if armed != rest.match(vals): + return False + return True + # 0|1 == 1|0 == 1, 0|0 == 1|1 == 0 + armed = False + for rest in self.restrictions: + if armed == rest.match(vals): + if armed: + return False + else: + if not armed: + armed = True + if armed: + return True + return False + + def force_True(self, pkg, *vals): + pvals = [pkg] + pvals.extend(vals) + entry_point = pkg.changes_count() + truths = [r.match(*pvals) for r in self.restrictions] + count = truths.count(True) + # get the simple one out of the way first. + l = len(truths) + if self.negate: + f = lambda r: r.force_False(*pvals) + t = lambda r: r.force_True(*pvals) + if count > l/2: order = ((t, count, True), (f, l - count, False)) + else: order = ((f, l - count, False), (t, count, True)) + for action, current, desired in order: + if current == l: + yield True + continue + for x, r in enumerate(self.restrictions): + if truths[x] != desired: + if action(r): + current += 1 + else: + break + if current == l: + yield True + pkg.rollback(entry_point) + return + + stack = [] + for x, val in enumerate(truths): + falses = filter(None, val) + if truths[x]: + falses.remove(x) + stack.append((falses, None)) + else: + stack.append((falses, x)) + + if count == 1: + yield True + del stack[truths.index(True)] + + for falses, truths in stack: + failed = False + for x in falses: + if not self.restrictions[x].force_False(*pvals): + failed = True + break + if not failed: + if trues != None: + if self.restrictions[x].force_True(*pvals): + yield True + else: + yield True + pkg.rollback(entry_point) + + + def force_False(self, pkg, *vals): + pvals = [pkg] + pvals.extend(vals) + entry_point = pkg.changes_count() + truths = [r.match(*pvals) for r in self.restrictions] + count = truths.count(True) + # get the simple one out of the way first. + l = len(truths) + if not self.negate: + f = lambda r: r.force_False(*pvals) + t = lambda r: r.force_True(*pvals) + if count > l/2: order = ((t, count, True), (f, l - count, False)) + else: order = ((f, l - count, False), (t, count, True)) + for action, current, desired in order: + if current == l: + yield True + continue + for x, r in enumerate(self.restrictions): + if truths[x] != desired: + if action(r): + current += 1 + else: + break + if current == l: + yield True + pkg.rollback(entry_point) + return + # the fun one. + stack = [] + for x, val in enumerate(truths): + falses = filter(None, val) + if truths[x]: + falses.remove(x) + stack.append((falses, None)) + else: + stack.append((falses, x)) + + if count == 1: + yield True + del stack[truths.index(True)] + + for falses, truths in stack: + failed = False + for x in falses: + if not self.restrictions[x].force_False(*pvals): + failed = True + break + if not failed: + if trues != None: + if self.restrictions[x].force_True(*pvals): + yield True + else: + yield True + pkg.rollback(entry_point) + + + def __str__(self): + if self.negate: return "not ( %s )" % " ^^ ".join(imap(str, self.restrictions)) + return "( %s )" % " ^^ ".join(imap(str, self.restrictions)) + + diff --git a/portage/restrictions/packages.py b/portage/restrictions/packages.py new file mode 100644 index 0000000..ae44150 --- /dev/null +++ b/portage/restrictions/packages.py @@ -0,0 +1,140 @@ +# Copyright: 2005 Gentoo Foundation +# Author(s): Brian Harring (ferringb@gentoo.org) +# License: GPL2 +# $Header: /local/data/ulm/cvs/history/var/cvsroot/gentoo-src/portage/portage/restrictions/packages.py,v 1.1 2005/08/16 00:19:57 ferringb Exp $ + +import restriction +import boolean +from portage.util.lists import unique +import values + +class base(restriction.base): + package_matching = True + +class PackageRestriction(base): + """cpv data restriction. Inherit for anything that's more then cpv mangling please""" + + __slots__ = tuple(["attr_split", "attr", "restriction"] + base.__slots__) + + def __init__(self, attr, restriction, **kwds): + super(PackageRestriction, self).__init__(**kwds) + self.attr_split = attr.split(".") + self.attr = attr + if not isinstance(restriction, values.base): + raise TypeError("restriction must be of a restriction type") + self.restriction = restriction + + def __pull_attr(self, pkg): + try: + o = pkg + for x in self.attr_split: + o = getattr(o, x) + return o + except AttributeError,ae: + logging.debug("failed getting attribute %s from %s, exception %s" % \ + (self.attr, str(pkg), str(ae))) + raise + + def match(self, pkg): + try: + return self.restriction.match(self.__pull_attr(pkg)) ^ self.negate + except AttributeError: + return self.negate + + + def force_False(self, pkg): +# import pdb;pdb.set_trace() + if self.negate: + i = self.restriction.force_True(pkg, self.attr, self.__pull_attr(pkg)) + else: + i = self.restriction.force_False(pkg, self.attr, self.__pull_attr(pkg)) + if isinstance(i, bool): + yield i + else: + for x in i: + yield True + return + + def force_True(self, pkg): +# import pdb;pdb.set_trace() + if self.negate: + i = self.restriction.force_False(pkg, self.attr, self.__pull_attr(pkg)) + else: + i = self.restriction.force_True(pkg, self.attr, self.__pull_attr(pkg)) + if isinstance(i, bool): + yield i + else: + for x in i: + yield True + return + + + def __getitem__(self, key): + if not isinstance(self.restriction, boolean.base): + if key != 0: + raise IndexError("restriction isn't indexable") + else: + return self + try: + g = self.restriction[key] + except TypeError: + if key == 0: + return self.restriction + raise IndexError("index out of range") + + def __len__(self): + if not isinstance(self.restriction, boolean.base): + return 1 + return len(self.restriction) + 1 + + def intersect(self, other): + if self.negate != other.negate or self.attr != other.attr: + return None + if isinstance(self.restriction, other.restriction.__class__): + s = self.restriction.intersect(other.restriction) + elif isinstance(other.restriction, self.restriction.__class__): + s = other.restriction.intersect(self.restriction) + else: return None + if s == None: + return None + if s == self.restriction: return self + elif s == other.restriction: return other + + # this can probably bite us in the ass self or other is a derivative, and the other isn't. + return self.__class__(self.attr, s) + + def __eq__(self, other): + return self.negate == self.negate and self.attr == other.attr and self.restriction == other.restriction + + def __str__(self): + s = self.attr + if self.negate: self.attr += "not " + return s + str(self.restriction) + + +class AndRestriction(base, boolean.AndRestriction): + __slots__ = tuple(unique(list(boolean.AndRestriction.__slots__) + base.__slots__)) + required_base = base + + +class OrRestriction(base, boolean.OrRestriction): + __slots__ = tuple(unique(list(boolean.OrRestriction.__slots__) + base.__slots__)) + required_base = base + +class XorRestriction(base, boolean.XorRestriction): + __slots__ = tuple(unique(list(boolean.XorRestriction.__slots__) + base.__slots__)) + required_base = base + +class AlwaysBoolRestriction(restriction.AlwaysBoolMatch, base): + __slots__=("negate") +def __init__(self, val): + self.negate = val +def match(self, *a): + return self.negate +def force_False(self, *a): + return self.negate == False +def force_True(self, *a): + return self.negate == True + +AlwaysTrue = AlwaysBoolRestriction(True) +AlwaysFalse = AlwaysBoolRestriction(True) diff --git a/portage/restrictions/restrictionSet.py b/portage/restrictions/restrictionSet.py deleted file mode 100644 index 67288d1..0000000 --- a/portage/restrictions/restrictionSet.py +++ /dev/null @@ -1,167 +0,0 @@ -# Copyright: 2005 Gentoo Foundation -# Author(s): Brian Harring (ferringb@gentoo.org) -# License: GPL2 -# $Header: /local/data/ulm/cvs/history/var/cvsroot/gentoo-src/portage/portage/restrictions/Attic/restrictionSet.py,v 1.9 2005/08/09 07:51:09 ferringb Exp $ - -""" -This module provides classes that can be used to combine arbitrary collections of restrictions in AND, NAND, OR, NOR, XOR, XNOR -style operations. -""" - -import restriction -from itertools import imap -__all__ = ("AndRestrictionSet", "OrRestrictionSet", "XorRestrictionSet") - -class RestrictionSet(restriction.base): - __slots__ = tuple(["restrictions"] + restriction.base.__slots__) - - def __init__(self, *restrictions, **kwds): - """Optionally hand in (positionally) restrictions to use as the basis of this restriction - finalize=False, set it to True to notify this instance to internally finalize itself (no way to reverse it yet) - negate=False, controls whether matching results are negated - """ - if "finalize" in kwds: - finalize = kwds["finalize"] - del kwds["finalize"] - else: - finalize = False - super(RestrictionSet, self).__init__(**kwds) - for x in restrictions: - if not isinstance(x, restriction.base): - #bad monkey. - raise TypeError, x - - if finalize: - self.restrictions = tuple(restrictions) - else: - self.restrictions = list(restrictions) - - - def add_restriction(self, *new_restrictions, **kwds): - """add restriction(s) - strict=True, set to false to disable isinstance checks to ensure all restrictions are restriction.base derivatives - """ - if len(new_restrictions) == 0: - raise TypeError("need at least one restriction handed in") - if kwds.get("strict", True): - for r in new_restrictions: - if not isinstance(r, restriction.base): - raise TypeError("instance '%s' isn't a restriction.base, and strict is on" % r) - - self.restrictions.extend(new_restrictions) - - def finalize(self): - self.restrictions = tuple(self.restrictions) - - def total_len(self): return sum(imap(lambda x: x.total_len(), self.restrictions)) + 1 - - def __len__(self): return len(self.restrictions) - - def __iter__(self): return iter(self.restrictions) - - def __getitem__(self, key): - return self.restrictions[key] - -def unwind_changes(pkg, pop_count, negate): - while pop_count: - pkg.pop_change() - pop_count-=1 - if negate: - return pkg - return None - -class AndRestrictionSet(RestrictionSet): - """Boolean AND grouping of restrictions.""" - __slots__ = tuple(RestrictionSet.__slots__) - - def match(self, packagedataInstance): - for rest in self.restrictions: - if not rest.match(packagedataInstance): - return self.negate - return not self.negate - - def cmatch(self, pkg): - entry_point = pkg.changes_count() - for rest in self.restrictions: - if c.match(pkg) == False: - pkg.rollback_changes(entry_point) - if self.negate: return pkg - return self.negate - - # for this to be reached, things went well. - if self.negate: - pkg.rollback_changes(entry_point) - # yes, normally it's "not negate", but we no negates status already via the if - return False - return True - - def __str__(self): - if self.negate: return "not ( %s )" % " && ".join(imap(str, self.restrictions)) - return "( %s )" % " && ".join(imap(str, self.restrictions)) - - -class OrRestrictionSet(RestrictionSet): - """Boolean OR grouping of restrictions.""" - __slots__ = tuple(RestrictionSet.__slots__) - - def match(self, packagedataInstance): - for rest in self.restrictions: - if rest.match(packagedataInstance): - return not self.negate - return self.negate - - def cmatch(self, pkg): - entry_point = pkg.changes_count() - for rest in self.restrictions: - if rest.cmatch(pkg) == True: - if self.negate: - pkg.rollback_changes(entry_point) - return not self.negate - else: - pkg.rollback_changes(entry_point) - - if self.negate: - pkg.rollback_changes(entry_point) - return self.negate - - def __str__(self): - if self.negate: return "not ( %s )" % " || ".join(imap(str, self.restrictions)) - return "( %s )" % " || ".join(imap(str, self.restrictions)) - - -class XorRestrictionSet(RestrictionSet): - """Boolean XOR grouping of restrictions.""" - __slots__ = tuple(RestrictionSet.__slots__) - - def match(self, pkginst): - armed = False - for rest in self.restrictions: - if rest.match(pkginst): - if armed: - return self.negate - armed = True - return armed ^ self.negate - - def cmatch(self, pkg): - entry_point = None - armed = False - for ret in self.restrictions: - node_entry_point = pkg.changes_count() - if rest.cmatch(pkg): - if armed: - pkg.rollback_changes(entry_point) - return self.negate - armed = True - else: - pkg.rollback_changes(node_entry_point) - - if self.negate and entry_point != None: - pkg.rollback_changes(entry_point) - return armed ^ self.negate - - def __str__(self): - if self.negate: return "not ( %s )" % " ^^ ".join(imap(str, self.restrictions)) - return "( %s )" % " ^^ ".join(imap(str, self.restrictions)) - - -bases = (AndRestrictionSet, OrRestrictionSet, XorRestrictionSet) diff --git a/portage/restrictions/values.py b/portage/restrictions/values.py new file mode 100644 index 0000000..8e96442 --- /dev/null +++ b/portage/restrictions/values.py @@ -0,0 +1,286 @@ +# Copyright: 2005 Gentoo Foundation +# Author(s): Brian Harring (ferringb@gentoo.org) +# License: GPL2 +# $Header: /local/data/ulm/cvs/history/var/cvsroot/gentoo-src/portage/portage/restrictions/values.py,v 1.1 2005/08/16 00:19:57 ferringb Exp $ + +import re, logging +import restriction +import boolean + +class base(restriction.base): + """base restriction matching object; overrides setattr to provide the usual write once trickery + all derivatives *must* be __slot__ based""" + + __slots__ = restriction.base.__slots__ + + def force_True(self, pkg, attr, val): + if self.match(val) ^ self.negate: return True + elif self.negate: return pkg.request_disable(attr, val) + else: return pkg.request_enable(attr, val) + + def force_False(self, pkg, attr, val): + if self.match(val) ^ self.negate: return True + elif self.negate: return pkg.request_enable(attr, val) + else: return pkg.request_disable(attr, val) + + +class VersionRestriction(base): + """use this as base for version restrictions, gives a clue to what the restriction does""" + pass + + +class StrMatch(base): + """ Base string matching restriction. all derivatives must be __slot__ based classes""" + __slots__ = ["flags"] + base.__slots__ + pass + + +class StrRegexMatch(StrMatch): + #potentially redesign this to jit the compiled_re object + __slots__ = tuple(["regex", "compiled_re"] + StrMatch.__slots__) + + def __init__(self, regex, CaseSensitive=True, **kwds): + super(StrRegexMatch, self).__init__(**kwds) + self.regex = regex + flags = 0 + if not CaseSensitive: + flags = re.I + self.flags = flags + self.compiled_re = re.compile(regex, flags) + + def match(self, value): + return (self.compiled_re.match(str(value)) != None) ^ self.negate + + def intersect(self, other): + if self.regex == other.regex and self.negate == other.negate and self.flags == other.flags: + return self + return None + + def __eq__(self, other): + return self.regex == other.regex and self.negate == other.negate and self.flags == other.flags + + def __str__(self): + if self.negate: return "not like %s" % self.regex + return "like %s" % self.regex + + +class StrExactMatch(StrMatch): + __slots__ = tuple(["exact", "flags"] + StrMatch.__slots__) + + def __init__(self, exact, CaseSensitive=True, **kwds): + super(StrExactMatch, self).__init__(**kwds) + if not CaseSensitive: + self.flags = re.I + self.exact = str(exact).lower() + else: + self.flags = 0 + self.exact = str(exact) + + def match(self, value): + if self.flags & re.I: return (self.exact == str(value).lower()) ^ self.negate + else: return (self.exact == str(value)) ^ self.negate + + def intersect(self, other): + s1, s2 = self.exact, other.exact + if other.flags and not self.flags: + s1 = s1.lower() + elif self.flags and not other.flags: + s2 = s2.lower() + if s1 == s2 and self.negate == other.negate: + if other.flags: + return other + return self + return None + + def __eq__(self, other): + return self.exact == other.exact and self.negate == other.negate and self.flags == other.flags + + def __str__(self): + if self.negate: return "!= "+self.exact + return "== "+self.exact + + +class StrGlobMatch(StrMatch): + __slots__ = tuple(["glob"] + StrMatch.__slots__) + def __init__(self, glob, CaseSensitive=True, **kwds): + super(StrGlobMatch, self).__init__(**kwds) + if not CaseSensitive: + self.flags = re.I + self.glob = str(glob).lower() + else: + self.flags = 0 + self.glob = str(glob) + + def match(self, value): + if isinstance(value, (list, tuple)): + for x in value: + print "trying %s against %s" % (x, self.glob) + if self.match(x): + return not self.negate + return self.negate + else: + value = str(value) + if self.flags & re.I: value = value.lower() + return value.startswith(self.glob) ^ self.negate + + def intersect(self, other): + if self.match(other.glob): + if self.negate == other.negate: + return other + elif other.match(self.glob): + if self.negate == other.negate: + return self + return None + + def __eq__(self, other): + return self.glob == other.glob and self.negate == other.negate and self.flags == other.flags + + def __str__(self): + if self.negate: return "not "+self.glob+"*" + return self.glob+"*" + + +class ContainmentMatch(base): + """used for an 'in' style operation, 'x86' in ['x86','~x86'] for example + note that negation of this *does* not result in a true NAND when all is on.""" + __slots__ = tuple(["vals", "vals_len", "all"] + base.__slots__) + + def __init__(self, *vals, **kwds): + """vals must support a contaiment test + if all is set to True, all vals must match""" + + if "all" in kwds: + self.all = kwds["all"] + del kwds["all"] + else: + self.all = False + super(ContainmentMatch, self).__init__(**kwds) + self.vals = set(vals) + self.vals_len = len(self.vals) + + def match(self, val): + if isinstance(val, (str, unicode)): + return val in self.vals ^ self.negate + rem = set(self.vals) + try: + # assume our lookup is faster, since we don't know if val is constant lookup or not + for x in val: + if x in rem: + if self.all: + rem.remove(x) + if len(rem) == 0: + return not self.negate + else: + return not self.negate + return self.negate + except TypeError: + return self.negate +# return val in self.vals ^ self.negate + + def force_False(self, pkg, attr, val): + if isinstance(val, (str, unicode)): + # unchangable + if self.all: + if len(self.vals) != 1: + yield False + else: + yield (self.vals[0] in val) ^ self.negate + else: + yield (val in self.vals) ^ self.negate + return + + entry = pkg.changes_count() + if self.negate: + if self.all: + def filter(truths): return False in truths + def true(r, pvals): return pkg.request_enable(attr, r) + def false(r, pvals): return pkg.request_disable(attr, r) + + truths = [x in val for x in self.vals] + + for x in boolean.iterative_quad_toggling(pkg, None, list(self.vals), 0, len(self.vals), truths, filter, + desired_false=false, desired_true=true): + yield True + else: + if pkg.request_disable(attr, *self.vals): + yield True + return + + if not self.all: + if pkg.request_disable(attr, *self.vals): + yield True + else: + l = len(self.vals) + def filter(truths): return truths.count(True) < l + def true(r, pvals): return pkg.request_enable(attr, r) + def false(r, pvals): return pkg.request_disable(attr, r) + truths=[x in val for x in self.vals] + for x in boolean.iterative_quad_toggling(pkg, None, list(self.vals), 0, l, truths, filter, + desired_false=false, desired_true=true): + yield True + + return + + + def force_True(self, pkg, attr, val): + import pdb;pdb.set_trace() + if isinstance(val, (str, unicode)): + # unchangable + if self.all: + if len(self.vals) != 1: + yield False + else: + yield (self.vals[0] in val) ^ self.negate + else: + yield (val in self.vals) ^ self.negate + return + + entry = pkg.changes_count() + if not self.negate: + if not self.all: + def filter(truths): return True in truths + def true(r, pvals): return pkg.request_enable(attr, r) + def false(r, pvals): return pkg.request_disable(attr, r) + + truths = [x in val for x in self.vals] + + for x in boolean.iterative_quad_toggling(pkg, None, list(self.vals), 0, len(self.vals), truths, filter, + desired_false=false, desired_true=true): + yield True + else: + if pkg.request_enable(attr, *self.vals): + yield True + return + + # negation + if not self.all: + if pkg.request_disable(attr, *self.vals): + yield True + else: + def filter(truths): return True not in truths + def true(r, pvals): return pkg.request_enable(attr, r) + def false(r, pvals): return pkg.request_disable(attr, r) + truths=[x in val for x in self.vals] + for x in boolean.iterative_quad_toggling(pkg, None, list(self.vals), 0, len(self.vals), truths, filter, + desired_false=false, desired_true=true): + yield True + return + + + def __str__(self): + if self.negate: s="not contains [%s]" + else: s="contains [%s]" + return s % ', '.join(map(str, self.vals)) + +def get_val(pkg, attr): + attr_list = '.'.split(attr) + o=pkg + try: + for x in attr: + o=getattr(o, x) + return x + except AttributeError, ae: + logger.warn("impossible happened, unable to get attr '%s' from pkg '%s', yet it was handed into my parent" + % (attr, pkg)) + raise + -- cgit v1.2.3-65-gdbad