def _func_settings(self, func): #{{{
     global_settings = self._vars['global_settings']
     mk_sig = global_settings.pop('MAKE_SIGNAL', 0)
     s = self._csettings()
     options = self._func_settings_options(s, global_settings)
     block = self._blocked_func_settings()
     custom_block = self._custom_blocked_func_settings
     news = dict((k, v) for k, v in s.iteritems() if k not in block and not custom_block(k))
     ism = bool(s.get('ismethod', False))
     istup = isinstance(func, tuple)
     meth_app = self._vars['methods'].append
     # Add to methods var so callfunc can process both
     # conditional callables and target callables
     if ism:
         callmeth = bool(s.get('callmethod', False))
         if callmeth and not mk_sig:
             if options['overload']:
                 raise ValueError("Keywords 'overload' and 'callmethod' cannot be True at the same time")
             func_obj = func[1] if istup else func
             name, vardict = func_obj.__name__, dict()
             # Low-level function creation to avoid use of exec
             # which allows turning this class into a builtin type
             args, vargs, vkeys, defaults = spec = cgetargspec(func_obj)
             code_args = args + [v for v in (vargs, vkeys) if v != None]
             fcode = Code(CodeList(), (), code_args, bool(vargs), bool(vkeys), True, 'f', '<dyn>', 1, None)
             fcode.code[:] = ([(SetLineno, 2), (LOAD_GLOBAL, 'getattr'),
                               (LOAD_FAST, 'self'), (LOAD_CONST, name),
                               (CALL_FUNCTION, 2),
                             ] + bp_call_args(callmethod=True, *spec) + 
                             [(RETURN_VALUE, None)])
             f = newfunction(fcode.to_code(), dict(getattr=getattr), 'f', default_argvals(args, defaults))
             func = (func[0], f) if istup else f
         if istup:
             for f in func:
                 meth_app(f)
         else:
             meth_app(func)
     return func, news, options
        def factory(func):
            args, vargs, vkeys, defaults = spec = cgetargspec(func)
            names = set(list(args) + [vargs, vkeys])
            n, _join, csg = 'cs_str', ''.join, dict(__builtin__.__dict__)
            csg.update(self.connect_settings.get('globals', {}))

            # Find name that is unbound 
            while n in names or n in csg:
                n = _join(n, '_')

            # Pre-compile expression into a code object
            csg[n] = compile_str(s.strip(), __file__, 'eval')

            # Build a new function
            code_args = args + [v for v in (vargs, vkeys) if v != None]
            fcode = Code(CodeList(), (), code_args, bool(vargs), bool(vkeys), True, 'whenfunc', '<dyn>', 1, None)
            fcode.code[:] = ([(SetLineno, 2), (LOAD_GLOBAL, 'bool'), (LOAD_GLOBAL, 'eval'),
                                (LOAD_GLOBAL, n), (CALL_FUNCTION, 1), (CALL_FUNCTION, 1), 
                                (RETURN_VALUE, None)])
            whenfunc = newfunction(fcode.to_code(), csg, 'whenfunc', default_argvals(args, defaults))

            self._vars['settings']['weakcondf'] = False
            return condfunc(whenfunc)(func)
 def settings(func): #{{{
     signal = getattr(func, 'signal', None)
     if isinstance(signal, DecoSignalExtension) and isinstance(signal, BaseSignal):
         DecoSignalFunction = func
     elif not _isf(func) and not isclass(func):
         raise TypeError('argument must be a python function or a python class')
     else:
         signal = mkdeco(func, opt)
         args, vargs, vkeys, defaults = spec = cgetargspec(func)
         code_args = args + [v for v in (vargs, vkeys) if v != None]
         fcode = Code(CodeList(), (), code_args, bool(vargs), bool(vkeys), True, 'f', '<dynamic decorator signal function>', 1, None)
         fcode.code[:] = ([(SetLineno, 2), (LOAD_GLOBAL, 'signal')] + bp_call_args(*spec) + 
                         [(RETURN_VALUE, None)])
         DecoSignalFunction = newfunction(fcode.to_code(), locals(), 'DecoSignalFunction', default_argvals(args, defaults))
     d = DecoSignalFunction
     d = wraps(func)(d)
     d.signal = signal
     signal.signalfunc = d
     for n in signal.decorators:
         setattr(d, n, getattr(signal, n))
     opt['MAKE_SIGNAL'] = 1
     return global_settings(d, **opt)(d)
        def factory(func):
            args, vargs, vkeys, defaults = cgetargspec(func)
            names = set(list(args) + [vargs, vkeys])
            n, sn, _join, csg = 'cs_str', 'cs_stop_str', ''.join, dict(__builtin__.__dict__)
            csg['StopCascade'] = StopCascade
            csg.update(self.connect_settings.get('globals', {}))

            # Find names that are unbound 
            while n in names or n in csg:
                n = _join(n, '_')
            while sn in names or sn in csg:
                sn = _join(sn, '_')

            # Pre-compile expression into a code object
            csg[n] = compile_str(s.strip(), '<dynamic cascade expression>', 'eval')
            csg[sn] = (stop if not isinstance(stop, basestring) 
                            else compile_str(str(stop).strip(), '<dynamic cascade stop condition>', 'eval'))

            # Build a new function:
            # def cascadefunc(*args, **kwargs): # Not really, dynamically generate args
            #     ret = bool(eval(s))
            #     if isinstance(stop, basestring):
            #         stop = eval(stop)
            #     if bool(stop):
            #         raise StopCascade(ret)
            #     return ret
            code_args = args + [v for v in (vargs, vkeys) if v != None]
            fcode = Code(CodeList(), (), code_args, bool(vargs), bool(vkeys), True, 'cascadefunc', '<dynamic cascade function>', 1, None)
            labels = map(lambda i: Label(), xrange(4))
            fcode.code[:] = ([(SetLineno, 2), 
                              (LOAD_GLOBAL, 'bool'), 
                              (LOAD_GLOBAL, 'eval'),
                              (LOAD_GLOBAL, n), 
                              (CALL_FUNCTION, 1), 
                              (CALL_FUNCTION, 1), 
                              (STORE_FAST, 'ret'), 

                              (SetLineno, 3), 
                              (LOAD_GLOBAL, sn), 
                              (STORE_FAST, 'stop'), 

                              (SetLineno, 4), 
                              (LOAD_GLOBAL, 'isinstance'),
                              (LOAD_FAST, 'stop'),
                              (LOAD_GLOBAL, 'basestring'),
                              (CALL_FUNCTION, 2), 
                              (JUMP_IF_FALSE, labels[0]),
                              (POP_TOP, None),

                              (SetLineno, 5), 
                              (LOAD_GLOBAL, 'eval'),
                              (LOAD_FAST, 'stop'),
                              (CALL_FUNCTION, 1), 
                              (STORE_FAST, 'stop'), 
                              (JUMP_FORWARD, labels[1]), 
                              (labels[0], None), 
                              (POP_TOP, None),
                              (labels[1], None), 

                              (SetLineno, 6), 
                              (LOAD_FAST, 'stop'),
                              (JUMP_IF_FALSE, labels[2]),
                              (POP_TOP, None),

                              (SetLineno, 7), 
                              (LOAD_GLOBAL, 'StopCascade'),
                              (LOAD_FAST, 'ret'),
                              (CALL_FUNCTION, 1),
                              (RAISE_VARARGS, 1),
                              (JUMP_FORWARD, labels[3]),
                              (labels[2], None),
                              (POP_TOP, None),

                              (SetLineno, 8),
                              (labels[3], None),
                              (LOAD_FAST, 'ret'),

                              (RETURN_VALUE, None)])
            cascadefunc = newfunction(fcode.to_code(), csg, 'cascadefunc', default_argvals(args, defaults))
            self._vars['settings']['weakcondf'] = False
            return condfunc(cascadefunc)(func)