pass def query(self, *args, **kw): """Call registered hooks (w/given args), yielding each result""" if kw: for hook in self: yield hook(*args, **kw) elif args: for hook in self: yield hook(*args) else: for hook in self: yield hook() struct(Hook) def Hook(group, impl=None): """Easy access to a specific entry point or group of entry points""" return group, impl _implementations = {} # global implementation registry class PluginManager(context.Service): """Manage plugin eggs""" def addEntryPoint(self, group, impl, ob): """Register an object as a hook"""
return action # Rules management def abstract(func=None): """Declare a function to be abstract""" if func is None: return decorate_assignment( lambda f,n,func,old: Dispatching(func).as_abstract() ) else: return Dispatching(func).as_abstract() next_sequence = itertools.count().next struct() def Rule(body, predicate=(), actiontype=None, sequence=None): if sequence is None: sequence = next_sequence() return body, predicate, actiontype, sequence struct() def ParseContext( body, actiontype=None, localdict=(), globaldict=(), lineno=None, sequence=None ): """Hold information needed to parse a predicate""" if sequence is None: sequence = next_sequence() return body, actiontype, dict(localdict), dict(globaldict), lineno, sequence def parse_rule(engine, predicate, context, cls):
Note that a Disjunction can never have less than 2 members, as creating a Disjunction with only 1 item returns that item, and creating one with no items returns ``False`` (as no acceptable conditions means "never true"). """ __slots__ = () def __new__(cls, input): if cls is Disjunction: return DisjunctionSet(input) return super(Disjunction, cls).__new__(cls) when(negate, (Disjunction, ))(lambda c: reduce(intersect, map(negate, c))) struct() def Range(lo=(Min, -1), hi=(Max, 1)): if hi <= lo: return False return lo, hi struct() def Value(value, match=True): return value, match when(implies, (Value, Range))(
if dependent.dirty(): ctrl.schedule(dependent) # process reads in normal fashion ctrl._process_reads(self) except: ctrl.reads.clear() ctrl.writes.clear() raise finally: ctrl.current_listener = None Pause = symbols.Symbol('Pause', __name__) decorators.struct() def Return(value): """Wrapper for yielding a value from a task""" return value, def resume(): """Get the result of a nested task invocation (needed for Python<2.5)""" c = trellis.ctrl.current_listener if not isinstance(c, TaskCell):
Note that a Disjunction can never have less than 2 members, as creating a Disjunction with only 1 item returns that item, and creating one with no items returns ``False`` (as no acceptable conditions means "never true"). """ __slots__ = () def __new__(cls, input): if cls is Disjunction: return DisjunctionSet(input) return super(Disjunction, cls).__new__(cls) when(negate, (Disjunction,))(lambda c: reduce(intersect, map(negate, c))) struct() def Range(lo=(Min, -1), hi=(Max, 1)): if hi <= lo: return False return lo, hi struct() def Value(value, match=True): return value, match
return action # Rules management def abstract(func=None): """Declare a function to be abstract""" if func is None: return decorate_assignment( lambda f,n,func,old: Dispatching(func).as_abstract() ) else: return Dispatching(func).as_abstract() next_sequence = getattr(itertools.count(), NEXT) struct() def Rule(body, predicate=(), actiontype=None, sequence=None): if sequence is None: sequence = next_sequence() return body, predicate, actiontype, sequence struct() def ParseContext( body, actiontype=None, localdict=(), globaldict=(), lineno=None, sequence=None ): """Hold information needed to parse a predicate""" if sequence is None: sequence = next_sequence() return body, actiontype, dict(localdict), dict(globaldict), lineno, sequence def parse_rule(engine, predicate, context, cls):