Exemplo n.º 1
0
 def _init_calls_around(self, cleanlist, have_slotfunc): #{{{
     def call_streamin(self): #{{{
         def streamin_wrap(func): #{{{
             def wrap(cw, *args, **kwargs): #{{{
                 if have_slotfunc('streamin'):
                     sig, signame = None, cw.__name__
                     if args:
                         for cls in mro(args[0].__class__):
                             sig = getsignal(getattr(cls, signame, None))
                             if sig and cw is sig.func:
                                 break
                         else:
                             sig = None
                     if sig:
                         args = (args[0], list(args[1:]), kwargs)
                     else:
                         args = (list(args), kwargs)
                     callfunc = self.caller
                     for sfunc, t in cleanlist('streamin'):
                         callfunc(self, sfunc, 'streamin', False, None, *args)
                     if sig:
                         args, kwargs = [args[0]] + args[1], args[2]
                     else:
                         args, kwargs = args
                 return func(*args, **kwargs)
             # End def #}}}
             return wrap
         # End def #}}}
         yield streamin_wrap
     # End def #}}}
     sup = super(StreamExtension, self)._init_calls_around(cleanlist, have_slotfunc)
     ret = odict(sup.iteritems())
     ret['streamin'] = call_streamin
     return ret
Exemplo n.º 2
0
 def _init_calls_after(self, cleanlist): #{{{
     def call_after(self, cw, func, ret, args, kwargs): #{{{
         callfunc = self.caller
         for afunc, t in cleanlist('after'):
             callfunc(self, afunc, 'after', False, None, *args, **kwargs)
         return ret
     # End def #}}}
     return odict(after=call_after)
Exemplo n.º 3
0
 def _init_calls_before(self, cleanlist): #{{{
     def call_before(self, cw, func, ret, args, kwargs): #{{{
         callfunc = self.caller
         for bfunc, t in cleanlist('before'):
             callfunc(self, bfunc, 'before', False, None, *args, **kwargs)
         return ret
     # End def #}}}
     return odict(before=call_before)
Exemplo n.º 4
0
 def _init_calls_after(self, cleanlist): #{{{
     def call_stream(self, cw, func, ret, args, kwargs): #{{{
         callfunc = self.caller
         for sfunc, t in cleanlist('stream'):
             ret = callfunc(self, sfunc, 'stream', True, ret, *args, **kwargs)
         return ret
     # End def #}}}
     sup = super(StreamExtension, self)._init_calls_after(cleanlist)
     ret = odict()
     ret['stream'] = call_stream
     ret.update(sup.iteritems())
     return ret
Exemplo n.º 5
0
 def _init_calls_replace(self, cleanlist): #{{{
     def call_replace(self): #{{{
         def do_wrap(func): #{{{
             def newcall(cw, *args, **kwargs): #{{{
                 callfunc, rfunc, ret = self.caller, None, None
                 for sfunc, t in cleanlist('replace'):
                     rfunc = sfunc
                 if rfunc:
                     ret = callfunc(self, rfunc, 'replace', False, ret, *args, **kwargs)
                 else:
                     ret = func(*args, **kwargs)
                 return ret
             # End def #}}}
             return newcall
         # End def #}}}
         # Need to return an iterator
         yield do_wrap
     # End def #}}}
     choice, callchoice = make_choice_helpers(self, callfunc, cleanlist)
     def call_choose(self): #{{{
         def do_wrap(func): #{{{
             def newcall(cw, *args, **kwargs): #{{{
                 func_choice = choice(self, 'choose', 'chooser', self.chooser_policy, func, False, None, *args, **kwargs)
                 return callchoice(self, func, func_choice, False, None, *args, **kwargs)
             # End def #}}}
             return newcall
         # End def #}}}
         # Need to return an iterator
         yield do_wrap
     # End def #}}}
     def call_choosereturn(self): #{{{
         def do_wrap(func): #{{{
             def newcall(cw, *args, **kwargs): #{{{
                 ret = func(*args, **kwargs)
                 ret_choice = choice(self, 'choosereturn', 'return_chooser', self.return_chooser_policy, 
                         func, True, ret, *args, **kwargs)
                 return callchoice(self, func, ret_choice, True, ret, *args, **kwargs)
             # End def #}}}
             return newcall
         # End def #}}}
         # Need to return an iterator
         yield do_wrap
     # End def #}}}
     ret = odict()
     ret['replace'] = call_replace
     ret['choose'] = call_choose
     ret['choosereturn'] = call_choosereturn
     return ret
Exemplo n.º 6
0
    def __init__(self, signal, **kwargs): #{{{
        if not iscallable(signal):
            raise TypeError("Argument must be callable.")
        expected = ('weak', 'active', 'activate_on_call')
        if any(kw for kw in kwargs if kw not in expected):
            raise ValueError("Detected unexpected arguments: %s" %', '.join([found]))
        weak = kwargs.get('weak', True)
        self._func = CallableWrapper(signal, weak=weak)
        self.__name__ = self._func.__name__
        funclist = self._funclist = dict()
        conn = self._connections = dict()
        call_funclist = self._call_funclist = dict((n, odict()) for n in ('after', 'replace', 'around', 'before'))
        self._vars = getattr(self, '_vars', dict())
        self._vars.update(active=kwargs.get('active', True),
                callactivate=kwargs.get('activate_on_call', False), caller=callfunc)

        # Initialize values of function lists
        self._init_funclist(funclist)
        self._init_calls(call_funclist)
        self._init_connections(conn)
Exemplo n.º 7
0
 def _init_calls_after(self, cleanlist): #{{{
     def call_streamin(self, cw, func, ret, args, kwargs): #{{{
         callfunc, cnam, sig, signame = self.caller, 'streamin', None, cw.__name__
         if args:
             for cls in mro(args[0].__class__):
                 sig = getsignal(getattr(cls, signame, None))
                 if sig and cw is sig.func:
                     break
             else:
                 sig = None
         if sig:
             args = (args[0], list(args[1:]), kwargs)
         else:
             args = (list(args), kwargs)
         for sfunc, t in cleanlist(cnam):
             callfunc(self, sfunc, cnam, False, ret, *args)
         return ret
     # End def #}}}
     def call_stream(self, cw, func, ret, args, kwargs): #{{{
         callfunc = self.caller
         for sfunc, t in cleanlist('stream'):
             ret = callfunc(self, sfunc, 'stream', True, ret, *args, **kwargs)
         return ret
     # End def #}}}
     def call_onreturn(self, cw, func, ret, args, kwargs): #{{{
         callfunc = self.caller
         for rfunc, t in cleanlist('onreturn'):
             callfunc(self, rfunc, 'onreturn', True, ret, *args, **kwargs)
         return ret
     # End def #}}}
     sup = super(Signal, self)._init_calls_after(cleanlist)
     ret = odict()
     ret['streamin'] = call_streamin
     ret['stream'] = call_stream
     ret.update(sup.iteritems())
     ret['onreturn'] = call_onreturn
     return ret
Exemplo n.º 8
0
 def _init_calls_around(self, cleanlist): #{{{
     return odict()
Exemplo n.º 9
0
 def _init_calls_replace(self, cleanlist): #{{{
     return odict()
Exemplo n.º 10
0
 def _init_calls_around(self, cleanlist, have_slotfunc): #{{{
     return odict()
Exemplo n.º 11
0
 def _init_calls_replace(self, cleanlist, have_slotfunc): #{{{
     return odict()
Exemplo n.º 12
0
 def _init_calls_around(self, cleanlist): #{{{
     def call_around(self): #{{{
         return (arfunc for arfunc, _ in cleanlist('around'))
     # End def #}}}
     return odict(around=call_around)