def _exec(self, bound_names, args, kw): """Call a Python Script Calling a Python Script is an actual function invocation. """ self._updateFromFS() # Prepare the function. f = self._v_f __traceback_info__ = bound_names, args, kw, self.func_defaults if bound_names: # Updating func_globals directly is not thread safe here. # In normal PythonScripts, every thread has its own # copy of the function. But in FSPythonScripts # there is only one copy. So here's another way. new_globals = f.func_globals.copy() new_globals.update(bound_names) if f.func_defaults: f = new.function(f.func_code, new_globals, f.func_name, f.func_defaults) else: f = new.function(f.func_code, new_globals, f.func_name) # Execute the function in a new security context. security=getSecurityManager() security.addContext(self) try: result = apply(f, args, kw) return result finally: security.removeContext(self)
def test_closure(func, closure, exc): try: new.function(func.func_code, {}, "", None, closure) except exc: pass else: print "corrupt closure accepted"
def _exec(self, bound_names, args, kw): """Call a Python Script Calling a Python Script is an actual function invocation. """ # do caching keyset = None if self.ZCacheable_isCachingEnabled(): # Prepare a cache key. keyset = kw.copy() asgns = self.getBindingAssignments() name_context = asgns.getAssignedName('name_context', None) if name_context: keyset[name_context] = self.aq_parent.getPhysicalPath() name_subpath = asgns.getAssignedName('name_subpath', None) if name_subpath: keyset[name_subpath] = self._getTraverseSubpath() # Note: perhaps we should cache based on name_ns also. keyset['*'] = args result = self.ZCacheable_get(keywords=keyset, default=_marker) if result is not _marker: # Got a cached value. return result # Prepare the function. f = self._v_f if f is None: # The script has errors. __traceback_supplement__ = (FSPythonScriptTracebackSupplement, self, 0) raise RuntimeError, '%s has errors.' % self._filepath # Updating func_globals directly is not thread safe here. # In normal PythonScripts, every thread has its own # copy of the function. But in FSPythonScripts # there is only one copy. So here's another way. new_globals = f.func_globals.copy() new_globals['__traceback_supplement__'] = ( FSPythonScriptTracebackSupplement, self) new_globals['__file__'] = self._filepath new_globals['__name__'] = self.id if bound_names: new_globals.update(bound_names) if f.func_defaults: f = new.function(f.func_code, new_globals, f.func_name, f.func_defaults) else: f = new.function(f.func_code, new_globals, f.func_name) # Execute the function in a new security context. security = getSecurityManager() security.addContext(self) try: result = f(*args, **kw) if keyset is not None: # Store the result in the cache. self.ZCacheable_set(result, keywords=keyset) return result finally: security.removeContext(self)
def _exec(self, bound_names, args, kw): """Call a Python Script Calling a Python Script is an actual function invocation. """ # Prepare the function. f = self._v_f if f is None: # The script has errors. raise RuntimeError, '%s has errors.' % self._filepath __traceback_info__ = bound_names, args, kw, self.func_defaults if bound_names: # Updating func_globals directly is not thread safe here. # In normal PythonScripts, every thread has its own # copy of the function. But in FSPythonScripts # there is only one copy. So here's another way. new_globals = f.func_globals.copy() new_globals.update(bound_names) if f.func_defaults: f = new.function(f.func_code, new_globals, f.func_name, f.func_defaults) else: f = new.function(f.func_code, new_globals, f.func_name) # Execute the function in a new security context. security = getSecurityManager() security.addContext(self) try: result = apply(f, args, kw) return result finally: security.removeContext(self)
def _exec(self, bound_names, args, kw): """Call a Python Script Calling a Python Script is an actual function invocation. """ # do caching keyset = None if self.ZCacheable_isCachingEnabled(): # Prepare a cache key. keyset = kw.copy() asgns = self.getBindingAssignments() name_context = asgns.getAssignedName('name_context', None) if name_context: keyset[name_context] = self.aq_parent.getPhysicalPath() name_subpath = asgns.getAssignedName('name_subpath', None) if name_subpath: keyset[name_subpath] = self._getTraverseSubpath() # Note: perhaps we should cache based on name_ns also. keyset['*'] = args result = self.ZCacheable_get(keywords=keyset, default=_marker) if result is not _marker: # Got a cached value. return result # Prepare the function. f = self._v_f if f is None: # The script has errors. __traceback_supplement__ = ( FSPythonScriptTracebackSupplement, self, 0) raise RuntimeError, '%s has errors.' % self._filepath # Updating func_globals directly is not thread safe here. # In normal PythonScripts, every thread has its own # copy of the function. But in FSPythonScripts # there is only one copy. So here's another way. new_globals = f.func_globals.copy() new_globals['__traceback_supplement__'] = ( FSPythonScriptTracebackSupplement, self) new_globals['__file__'] = self._filepath new_globals['__name__'] = self.id if bound_names: new_globals.update(bound_names) if f.func_defaults: f = new.function(f.func_code, new_globals, f.func_name, f.func_defaults) else: f = new.function(f.func_code, new_globals, f.func_name) # Execute the function in a new security context. security=getSecurityManager() security.addContext(self) try: result = f(*args, **kw) if keyset is not None: # Store the result in the cache. self.ZCacheable_set(result, keywords=keyset) return result finally: security.removeContext(self)
def validate(form, code, data): # errors errors = {} # build re-usable restricted function components like in PythonScript path = 'undefined.py' code, g, defaults = prepare_restricted_function( 'context, data, errors', code, 'validate', path, [], ) # update globals g = g.copy() g['__file__'] = path # validate new.function(code, g, None, defaults)(form.context, data, errors) # set errors for name, message in errors.items(): # resolve field widget = None try: widget = form.widgets[name] except KeyError: for group in (form.groups or ()): try: widget = group.widgets[name] break except KeyError: pass if widget is None: continue # set error error = Invalid(message) snippet = getMultiAdapter( (error, form.request, widget, widget.field, form, form.context), IErrorViewSnippet, ) snippet.update() widget.error = snippet errors[name] = snippet # return errors return errors.values()
def __init__(self, obj, query=None): self.hit = obj[0] self.doc = obj[1] self.values = dict() if len(obj) > 2: self.explanation = obj[2] self.query = query self.index_model = sys.MODELS_REGISTERED.get_index_model( self.doc.get(constant.FIELD_NAME_INDEX_MODEL)) self._meta = self.index_model._meta self.meta = self._meta # attach local_attrs, except '__unicode__'. func_unicode = None for i in self.index_model.local_attrs: if i.func_name == "__unicode__": func_unicode = i continue setattr( self, i.func_name, new.instancemethod( new.function( i.im_func.func_code, i.im_func.func_globals, i.func_name, ), self, self.__class__, )) # attach '__unicode__' method. # If index_model does not have '__unicode__' method, use the indexed field, '__unicode__'. if func_unicode: __im_func = func_unicode.im_func func_unicode = new.instancemethod( new.function( __im_func.func_code, __im_func.func_globals, "__unicode_index_model__", ), self, self.__class__, ) self.__unicode_index_model__ = func_unicode
def __exit__(self,*args): frame = self._get_context_frame() retcode = super(namespace,self).__exit__(*args) funcode = copy.deepcopy(self.bytecode) # Ensure it's a properly formed func by always returning something funcode.code.append((LOAD_CONST,None)) funcode.code.append((RETURN_VALUE,None)) # Switch LOAD/STORE/DELETE_FAST/NAME to LOAD/STORE/DELETE_ATTR to_replace = [] for (i,(op,arg)) in enumerate(funcode.code): repl = self._replace_opcode((op,arg),frame) if repl: to_replace.append((i,repl)) offset = 0 for (i,repl) in to_replace: funcode.code[i+offset:i+offset+1] = repl offset += len(repl) - 1 # Create function object to do the manipulation funcode.args = ("_[namespace]",) funcode.varargs = False funcode.varkwargs = False funcode.name = "<withhack>" gs = self._get_context_frame().f_globals func = new.function(funcode.to_code(),gs) # Execute bytecode in context of namespace retval = func(self.namespace) if self.as_name is not None: self._set_context_locals({self.as_name:self.namespace}) return retcode
def compileMultiFn(comp, name, form): s = form argdefs = [] while s is not None: argdefs.append(MultiFn(comp, s.first())) s = s.next() argdefs = sorted(argdefs, lambda x, y: len(x.args) < len(y.args)) if len(filter(lambda x: x.lastisargs, argdefs)) > 1: raise CompilerException("Only one function overload may have variable number of arguments", form) code = [] args = [] for x in argdefs: code.extend(x.code) for x in x.args: if x not in args: args.append(x) code.append((LOAD_CONST, Exception)) code.append((CALL_FUNCTION, 0)) code.append((RAISE_VARARGS, 1)) c = Code(code, comp.closureList(), ["__argsv__"], True, False, True, str(Symbol.intern(comp.getNS().__name__, name.name)), "./clj/clojure/core.clj", 0, None) fn = new.function(c.to_code(), comp.ns.__dict__, name.name) return [(LOAD_CONST, fn)]
def compileFn(comp, name, form, orgform): locals, args, lastisargs, argsname = unpackArgs(form.first()) comp.pushLocals(locals) if orgform.meta() is not None: line = orgform.meta()[LINE_KEY] else: line = 0 code = [(SetLineno,line if line is not None else 0)] recurlabel = Label("recurLabel") recur = {"label": recurlabel, "args": args} code.append((recurlabel, None)) comp.pushRecur(recur) code.extend(compileImplcitDo(comp, form.next())) comp.popRecur() code.append((RETURN_VALUE,None)) comp.popLocals(locals) clist = comp.closureList() c = Code(code, comp.closureList(), args, lastisargs, False, True, str(Symbol.intern(comp.getNS().__name__, name.name)), "./clj/clojure/core.clj", 0, None) if not clist: c = new.function(c.to_code(), comp.ns.__dict__, name.name) return [(LOAD_CONST, c)]
def breadth_first_traversal( _old ): s = [] def _savenode( *args, **kwargs ): s.append( (args,kwargs) ) newglobal = _old.func_globals.copy() newglobal[_old.__name__] = _savenode _oldBF = new.function( _old.func_code, newglobal ) def _new( *args, **kwargs ): s.append( (args,kwargs) ) while( len(s)!=0 ): a, kwa = s.pop(0) _oldBF( *a, **kwa ) _new._decorator = _old _new.__name__ = _old.__name__ _new.__doc__ = _old.__doc__ return _new
def testFilenameAndOffset(self): src = u"a=1\nraise RuntimeError" globs = {} co = compile_function(src, "foo.py", "func_name", ["x", "y", "z"], lineno=100) exec co in globs f = globs['func_name'] # re-create the function - so we can bind to different globals # Note we need to manually setup __builtins__ for this new globs. globs = { 'g': 'call_globs', '__debug__': __debug__, "__builtins__": globs["__builtins__"] } f = new.function(f.func_code, globs, f.func_name) try: f(1, 2, 3) raise AssertionError, "not reached!" except RuntimeError: # The function line number is 1 frames back. It should point to # line 102 tb = sys.exc_info()[2].tb_next self.failUnlessEqual(tb.tb_frame.f_lineno, 102) self.failUnlessEqual(tb.tb_frame.f_code.co_filename, "foo.py")
def maybe_bind(func, bindings): """Apply expression bindings to arguments, if applicable""" if not bindings or not hasattr(func, 'func_code'): return func # no bindings or not a function args, varargs, varkw, defaults = inspect.getargspec(func) if not args or isinstance(args[0], basestring): return func # no args or first arg isn't a tuple for arg in args[0]: if not isinstance(arg, basestring): # nested tuple arg, not a binding return func for arg in args[0]: if arg in bindings: for arg in args[0]: if arg not in bindings: raise TypeError("Missing binding for %r" % arg) break else: return func # none of the tuple args are in the binding argtuple = Tuple([bindings[arg] for arg in args[0]]) c = Code.from_spec(func.func_name, args[1:], varargs, varkw) f = new.function(c.code(), func.func_globals, func.func_name, func.func_defaults) f.func_code = c.code() # make f's signature match func w/out tuple c.return_(call_thru(f, Const(func), [argtuple])) # call to match that f.func_code = c.code() # now include the actual body f.__predicate_bindings__ = bindings, func # mark for later optimization return f
def changed_name_function(f, newname): import new if matplotlib._python23: newf = new.function(f.func_code, f.func_globals, newname, f.func_defaults, f.func_closure) else: #if f.func_defaults is None: # argdefs = () #else: argdefs = f.func_defaults newf = new.function(f.func_code, f.func_globals, newname, argdefs) print f.func_defaults newf.__doc__ = f.__doc__ return newf
def RegisterConfig(name, *args): def y(): pass source = """def __init__(self, a): print "ACAAAAAAAAAA" """ #compiled_code = compile(source, name, "single") code = compile(source, name, "single") nlocals = 10 compiled_code = types.CodeType(1, nlocals, code.co_stacksize, code.co_flags, code.co_code, code.co_consts, code.co_names, code.co_varnames, code.co_filename, code.co_name, code.co_firstlineno, code.co_lnotab, code.co_freevars, code.co_cellvars) #compiled_code = y.func_code f = new.function(compiled_code, globals(), "init") print f("a") clase = new.classobj(name, (), {}) im = new.instancemethod(f, name, ()) setattr(clase, "__init__", im) return clase
def __makeTest(testName, html, text): testName = "test%s" % (testName,) testLambda = lambda self: self._testHTML2Markdown(html, text) testFunction = new.function(testLambda.func_code, {}, testName, closure=testLambda.func_closure) setattr(HTML2MarkdownTests, testName, new.instancemethod(testFunction, None, HTML2MarkdownTests))
def uncover(function): name = function.func_name code = function.func_code name = name[1:] if name[0] == "_" else name arguments = tuple((name[1:] if name[0] == "_" else name) for name in code.co_varnames[:code.co_argcount]) new_code = new.code( code.co_argcount, code.co_nlocals, code.co_stacksize, code.co_flags, code.co_code, code.co_consts, code.co_names, arguments + code.co_names, code.co_filename, code.co_name, code.co_firstlineno, code.co_lnotab) print function.func_closure new_function = new.function( new_code, function.func_globals, name, function.func_defaults, function.func_closure) return new_function
def setup_a_rules_to_p_funcs(ns): rules = [] for name, val in ns.items(): if name.startswith('a_'): name = name[2:] rule, action_maker = val # call all pre before all make_action, so that synth classes are # pre-defined (in pre methods) and can be used freely by make_actions action_maker.pre(name) rules.append((name, rule, action_maker)) for name, rule, action_maker in rules: action = action_maker.make_action() name = 'p_%s' % name # cannot set __name__ on a function and spark uses func.__name__ to gather rule name so ns[name] = new.function(action.func_code, action.func_globals, name, action.func_defaults, action.func_closure) if hasattr(action, '_spec'): # copy _spec ns[name]._spec = action._spec if hasattr(action, 'making'): # copy making ns[name].making = action.making ns[name].__doc__ = rule # add preprocessing, produced p_funcs expect a spec argument # wrap them appropriately def preprocess(self, rule, func): if hasattr(func, '_spec') and func._spec is not None: spec = func._spec else: spec = rule[1] return rule, lambda args: func(spec, args) ns['preprocess'] = preprocess
def test_callmethod_opcode(self): """ Tests code generated by pypy-c compiled with CALL_METHOD bytecode """ self.patch_opcodes('CALL_METHOD', 'LOOKUP_METHOD') try: class X: def m(self): return 3 def f(): x = X() return x.m() # this code is generated by pypy-c when compiling above f pypy_code = 't\x00\x00\x83\x00\x00}\x00\x00|\x00\x00\xc9\x01\x00\xca\x00\x00S' new_c = self.monkey_patch_code(f.func_code, 3, 3, pypy_code, ('X', 'x', 'm'), ('x',)) f2 = new.function(new_c, locals(), 'f') graph = self.codetest(f2) all_ops = self.all_operations(graph) assert all_ops['simple_call'] == 2 assert all_ops['getattr'] == 1 finally: self.unpatch_opcodes('CALL_METHOD', 'LOOKUP_METHOD')
def _function_named(fn, newname): try: fn.__name__ = newname except: fn = new.function(fn.func_code, fn.func_globals, newname, fn.func_defaults, fn.func_closure) return fn
def compileMultiFn(comp, name, form): s = form argdefs = [] while s is not None: argdefs.append(MultiFn(comp, s.first())) s = s.next() argdefs = sorted(argdefs, lambda x, y: len(x.args) < len(y.args)) if len(filter(lambda x: x.lastisargs, argdefs)) > 1: raise CompilerException("Only one function overload may have variable number of arguments", form) code = [] if len(argdefs) == 1 and not argdefs[0].lastisargs: hasvararg = False argslist = argdefs[0].args code.extend(argdefs[0].bodycode) else: hasvararg = True argslist = ["__argsv__"] for x in argdefs: code.extend(x.argcode) code.extend(x.bodycode) code.append((LOAD_CONST, Exception)) code.append((CALL_FUNCTION, 0)) code.append((RAISE_VARARGS, 1)) clist = map(lambda x: x.sym.name, comp.closureList()) code = expandMetas(code, comp) c = Code(code, clist, argslist, hasvararg, False, True, str(symbol(comp.getNS().__name__, name.name)), comp.filename, 0, None) if not clist: c = new.function(c.to_code(), comp.ns.__dict__, name.name) return [(LOAD_CONST, c)], c
def test_callmethod_opcode(self): """ Tests code generated by pypy-c compiled with CALL_METHOD bytecode """ flow_meth_names = flowcontext.FlowSpaceFrame.opcode_method_names pyframe_meth_names = PyFrame.opcode_method_names for name in ['CALL_METHOD', 'LOOKUP_METHOD']: num = bytecode_spec.opmap[name] locals()['old_' + name] = flow_meth_names[num] flow_meth_names[num] = pyframe_meth_names[num] try: class X: def m(self): return 3 def f(): x = X() return x.m() # this code is generated by pypy-c when compiling above f pypy_code = 't\x00\x00\x83\x00\x00}\x00\x00|\x00\x00\xc9\x01\x00\xca\x00\x00S' new_c = self.monkey_patch_code(f.func_code, 3, 3, pypy_code, ('X', 'x', 'm'), ('x',)) f2 = new.function(new_c, locals(), 'f') graph = self.codetest(f2) all_ops = self.all_operations(graph) assert all_ops['simple_call'] == 2 assert all_ops['getattr'] == 1 finally: for name in ['CALL_METHOD', 'LOOKUP_METHOD']: num = bytecode_spec.opmap[name] flow_meth_names[num] = locals()['old_' + name]
def maybe_bind(func, bindings): """Apply expression bindings to arguments, if applicable""" if not bindings or not hasattr(func, 'func_code'): return func # no bindings or not a function args, varargs, varkw, defaults = inspect.getargspec(func) if not args or isinstance(args[0], basestring): return func # no args or first arg isn't a tuple for arg in args[0]: if not isinstance(arg, basestring): # nested tuple arg, not a binding return func for arg in args[0]: if arg in bindings: for arg in args[0]: if arg not in bindings: raise TypeError("Missing binding for %r" % arg) break else: return func # none of the tuple args are in the binding argtuple = Tuple([bindings[arg] for arg in args[0]]) c = Code.from_spec(func.func_name, args[1:], varargs, varkw) f = new.function( c.code(), func.func_globals, func.func_name, func.func_defaults ) f.func_code = c.code() # make f's signature match func w/out tuple c.return_(call_thru(f, Const(func), [argtuple])) # call to match that f.func_code = c.code() # now include the actual body f.__predicate_bindings__ = bindings, func # mark for later optimization return f
def makeDeclFuncts(self, keyList, classNames, classes): functs = dict() for key in keyList: className = classNames.get(key) functName = className + "Const" functStr = ( "\ def " + functName + "(scanner,token):\ node= " + className + '(); node.type = "' + className + '"; node.value = token; return node' ) functCo = compile(functStr, "", "exec") ns = {} exec functCo in ns funct = new.function(ns[functName].func_code, globals(), functName) globals()[functName] = funct functs[key] = functName return functs
def mergeFunctionMetadata(f, g): """ Overwrite C{g}'s name and docstring with values from C{f}. Update C{g}'s instance dictionary with C{f}'s. To use this function safely you must use the return value. In Python 2.3, L{mergeFunctionMetadata} will create a new function. In later versions of Python, C{g} will be mutated and returned. @return: A function that has C{g}'s behavior and metadata merged from C{f}. """ try: g.__name__ = f.__name__ except TypeError: try: merged = new.function(g.func_code, g.func_globals, f.__name__, inspect.getargspec(g)[-1], g.func_closure) except TypeError: pass else: merged = g try: merged.__doc__ = f.__doc__ except (TypeError, AttributeError): pass try: merged.__dict__.update(g.__dict__) merged.__dict__.update(f.__dict__) except (TypeError, AttributeError): pass merged.__module__ = f.__module__ return merged
def compileFn(comp, name, form, orgform): locals, args, lastisargs, argsname = unpackArgs(form.first()) for x in locals: comp.pushAlias(x, FnArgument(x)) if orgform.meta() is not None: line = orgform.meta()[LINE_KEY] else: line = 0 code = [(SetLineno,line if line is not None else 0)] if lastisargs: code.extend(cleanRest(argsname.name)) recurlabel = Label("recurLabel") recur = {"label": recurlabel, "args": map(lambda x: comp.getAlias(symbol(x)).compileSet(comp), args)} code.append((recurlabel, None)) comp.pushRecur(recur) code.extend(compileImplcitDo(comp, form.next())) comp.popRecur() code.append((RETURN_VALUE,None)) comp.popAliases(locals) clist = map(lambda x: x.sym.name, comp.closureList()) code = expandMetas(code, comp) c = Code(code, clist, args, lastisargs, False, True, str(symbol(comp.getNS().__name__, name.name)), comp.filename, 0, None) if not clist: c = new.function(c.to_code(), comp.ns.__dict__, name.name) return [(LOAD_CONST, c)], c
def mergeFunctionMetadata(f, g): """ Overwrite C{g}'s name and docstring with values from C{f}. Update C{g}'s instance dictionary with C{f}'s. To use this function safely you must use the return value. In Python 2.3, L{mergeFunctionMetadata} will create a new function. In later versions of Python, C{g} will be mutated and returned. @return: A function that has C{g}'s behavior and metadata merged from C{f}. """ try: g.__name__ = f.__name__ except TypeError: try: merged = new.function( g.func_code, g.func_globals, f.__name__, inspect.getargspec(g)[-1], g.func_closure) except TypeError: pass else: merged = g try: merged.__doc__ = f.__doc__ except (TypeError, AttributeError): pass try: merged.__dict__.update(g.__dict__) merged.__dict__.update(f.__dict__) except (TypeError, AttributeError): pass merged.__module__ = f.__module__ return merged
def test_build_list_from_arg_opcode(self): """ Tests code generated by pypy-c compiled with BUILD_LIST_FROM_ARG bytecode """ if sys.version_info < (2, 7): py.test.skip("2.7 only test") self.patch_opcodes('BUILD_LIST_FROM_ARG') try: def f(): return [i for i in "abc"] # this code is generated by pypy-c when compiling above f pypy_code = 'd\x01\x00\xcb\x00\x00D]\x0c\x00}\x00\x00|\x00\x00^\x02\x00q\x07\x00S' new_c = self.monkey_patch_code(f.func_code, 3, 67, pypy_code, (), ('i', )) f2 = new.function(new_c, locals(), 'f') graph = self.codetest(f2) all_ops = self.all_operations(graph) assert all_ops == { 'newlist': 1, 'getattr': 1, 'simple_call': 1, 'iter': 1, 'next': 1 } finally: self.unpatch_opcodes('BUILD_LIST_FROM_ARG')
def test_callmethod_opcode(self): """ Tests code generated by pypy-c compiled with CALL_METHOD bytecode """ self.patch_opcodes('CALL_METHOD', 'LOOKUP_METHOD') try: class X: def m(self): return 3 def f(): x = X() return x.m() # this code is generated by pypy-c when compiling above f pypy_code = 't\x00\x00\x83\x00\x00}\x00\x00|\x00\x00\xc9\x01\x00\xca\x00\x00S' new_c = self.monkey_patch_code(f.func_code, 3, 3, pypy_code, ('X', 'x', 'm'), ('x', )) f2 = new.function(new_c, locals(), 'f') graph = self.codetest(f2) all_ops = self.all_operations(graph) assert all_ops['simple_call'] == 2 assert all_ops['getattr'] == 1 finally: self.unpatch_opcodes('CALL_METHOD', 'LOOKUP_METHOD')
def __init__(self, target, deep_decoration = True): """ Init a decorator. "deep_decoration" activates a wrapping of the original methods. If true, direct calls to the inner object methods will go through all decorators. This is especially sensible, when the inner object calls methods of its own. """ # the only datamember of a decorator self.__dict__['decoratee'] = target self.__dict__['dec_par'] = dict() # this is automatically forwarded to the inner decoratee target._outermost_decorator = self if deep_decoration and not isinstance(target, CRDecorator): # make the inner object decorator-aware # the mechanism is the same as if @decorator_sensitive would be # applied to each of the inner objects methods. # in some cases needed target._inner_decoratee = target # get methods members = getmembers(target) methods = [m for m in members if ismethod(m[1])] for m in methods: # wrap methods properly with decorator_sensitive(...) m_func = function(m[1].func_code, m[1].func_globals) m_func = decorator_sensitive(m_func) m_func = instancemethod(m_func, target) # do the monkey-'wrap' setattr(target, m[0], m_func)
def setup_a_rules_to_p_funcs(ns): rules = [] for name,val in ns.items(): if name.startswith('a_'): name = name[2:] rule,action_maker = val # call all pre before all make_action, so that synth classes are # pre-defined (in pre methods) and can be used freely by make_actions action_maker.pre(name) rules.append((name,rule,action_maker)) for name,rule,action_maker in rules: action = action_maker.make_action() name = 'p_%s' % name # cannot set __name__ on a function and spark uses func.__name__ to gather rule name so ns[name] = new.function(action.func_code,action.func_globals,name,action.func_defaults,action.func_closure) if hasattr(action,'_spec'): # copy _spec ns[name]._spec = action._spec if hasattr(action,'making'): # copy making ns[name].making = action.making ns[name].__doc__ = rule # add preprocessing, produced p_funcs expect a spec argument # wrap them appropriately def preprocess(self,rule,func): if hasattr(func,'_spec') and func._spec is not None: spec = func._spec else: spec = rule[1] return rule,lambda args: func(spec,args) ns['preprocess'] = preprocess
def __getattr__(self, name): blacklist = ['im_func', 'func_code', 'index_html'] if name.startswith('_') or name in blacklist: raise AttributeError(name) # Check if there is views/<self.__name__>.<name>.py in the theme, if not raise # noqa currentTheme = getCurrentTheme() if currentTheme is None: raise AttributeError(name) themeDirectory = queryResourceDirectory(THEME_RESOURCE_NAME, currentTheme) # noqa if themeDirectory is None: raise AttributeError(name) script = None scriptPath = "%s/%s.py" % (FRAGMENTS_DIRECTORY, self.__name__) if themeDirectory.isFile(scriptPath): script = themeDirectory.readFile(scriptPath) if 'def {0:}(self'.format(name) in script: script += '\n\nreturn {0:s}(self)'.format(name) else: script = None scriptPath = "%s/%s.%s.py" % (FRAGMENTS_DIRECTORY, self.__name__, name) if script is None and themeDirectory.isFile(scriptPath): script = themeDirectory.readFile(scriptPath) if script is None: raise AttributeError(name) # Set the default PythonScript bindings as globals script_globals = { 'script': self, 'context': self.context, 'container': Acquisition.aq_parent(self.context), 'traverse_subpath': '' } # Build re-usable restricted function components like in PythonScript try: code, g, defaults = prepare_restricted_function( 'self,*args,**kwargs', script or 'pass', name, scriptPath, script_globals.keys() ) except SyntaxError: raise AttributeError(name) # Update globals g = g.copy() g.update(script_globals) g['__file__'] = scriptPath func = new.function(code, g, None, defaults) # Return the func as instancemethod return types.MethodType(func, self)
def __makeTest(testName, html, text): testName = "test%s" % (testName, ) testLambda = lambda self: self._testHTML2Markdown(html, text) testFunction = new.function(testLambda.func_code, {}, testName, closure=testLambda.func_closure) setattr(HTML2MarkdownTests, testName, new.instancemethod(testFunction, None, HTML2MarkdownTests))
def load_func((flag, bytes)): if flag == 1: return cPickle.loads(bytes) code, glob, name, defaults, closure = marshal.loads(bytes) glob = dict((k, load_object(v)) for k, v in glob.items()) glob["__builtins__"] = __builtins__ closure = closure and reconstruct_closure([load_object(c) for c in closure]) or None return new.function(code, glob, name, defaults, closure)
def __call__(self, func): retvalue = self.opts.get("retvalue", None) if retvalue is opitypes.VectorType: retvalue = opitypes.VectorValue fargs = inspect.getargs(func.func_code)[0] args = [VarRef(arg, typ) for arg, typ in zip(fargs, self.types)] code = func.func_code names = code.co_names dct = {} dct.update(func.func_globals) for n in names: if n in opiexpr.__all__: dct[n] = getattr(opiexpr, n) elif n not in func.func_globals: dct[n] = VarRef(n) dct["Return"] = opiexpr.Return(retvalue) newfunc = new.function(code, dct, func.func_name, closure=func.func_closure) #args = dict((arg,VarRef(arg,typ)) for arg,typ in zip(args,self.types)) statements = newfunc(*args) ops = [] for a in reversed(args): ops.append( opcode("setvar" + a._type.varcode, a._name, None, -a._type.stacksize)) for s in statements: try: ops.extend(s._get_stmt_ops()) except: t, v, tb = sys.exc_info() for l in traceback.format_list(s._tb): sys.stderr.write(l) for l in traceback.format_exception_only(t, v): sys.stderr.write(l) tb = None raise return if not ops or ops[-1][0] != "exit": if retvalue is not None: ops.extend(opiexpr._get_ops(retvalue.default)) ops.append(opcode("exit")) cc = CompilerFrame() cc.stack = sum(a._type.stacksize for a in args) cc.max_stack = cc.stack cc.debugout = self.opts.get("debugout", False) for op in ops: cc.compile(op) if cc.debugout: print "max. stack usage: %i bytes" % cc.max_stack print cc.__dict__ code = O2DCode(cc) code.retvalue = retvalue code.argspec = self.types return code
def get_lapack_funcs(names, arrays=(), debug=0, force_clapack=1): """Return available LAPACK function objects with names. arrays are used to determine the optimal prefix of LAPACK routines. If force_clapack is True then available Atlas routine is returned for column major storaged arrays with rowmajor argument set to False. """ force_clapack = 0 # XXX: Don't set it true! The feature is unreliable # and may cause incorrect results. # See test_basic.test_solve.check_20Feb04_bug. ordering = [] for i in range(len(arrays)): t = arrays[i].dtype.char if t not in _type_conv: t = 'd' ordering.append((t, i)) if ordering: ordering.sort() required_prefix = _type_conv[ordering[0][0]] else: required_prefix = 'd' dtypechar = _inv_type_conv[required_prefix] # Default lookup: if ordering and arrays[ordering[0][1]].flags['FORTRAN']: # prefer Fortran code for leading array with column major order m1, m2 = flapack, clapack else: # in all other cases, C code is preferred m1, m2 = clapack, flapack if not _use_force_clapack: force_clapack = 0 funcs = [] m1_name = m1.__name__.split('.')[-1] m2_name = m2.__name__.split('.')[-1] for name in names: func_name = required_prefix + name func = getattr(m1, func_name, None) if func is None: func = getattr(m2, func_name) func.module_name = m2_name else: func.module_name = m1_name if force_clapack and m1 is flapack: func2 = getattr(m2, func_name, None) if func2 is not None: import new func_code = None # defined in exec exec(_colmajor_func_template % {'func_name': func_name}) func = new.function(func_code, {'clapack_func': func2}, func_name) func.module_name = m2_name func.__doc__ = func2.__doc__ func.prefix = required_prefix func.dtypechar = dtypechar funcs.append(func) return tuple(funcs)
def load_func((flag, bytes)): if flag == 1: return cPickle.loads(bytes) code, glob, name, defaults, closure = marshal.loads(bytes) glob = dict((k, load_object(v)) for k, v in glob.items()) glob['__builtins__'] = __builtins__ closure = closure and reconstruct_closure( [load_object(c) for c in closure]) or None return new.function(code, glob, name, defaults, closure)
def get(method, user): fn = Resolver().resolve(method) debug("Internal resolve to function '%s'" % (method), module="api-resolve-internal") if isinstance(fn, apimethod): return fn.as_user(user) else: glob = fn.func_globals.copy() glob.update({"user": user}) return new.function(fn.func_code, glob, argdefs=fn.func_defaults)
def get_lapack_funcs(names,arrays=(),debug=0,force_clapack=1): """Return available LAPACK function objects with names. arrays are used to determine the optimal prefix of LAPACK routines. If force_clapack is True then available Atlas routine is returned for column major storaged arrays with rowmajor argument set to False. """ force_clapack = 0 # XXX: Don't set it true! The feature is unreliable # and may cause incorrect results. # See test_basic.test_solve.check_20Feb04_bug. ordering = [] for i in range(len(arrays)): t = arrays[i].dtype.char if t not in _type_conv: t = 'd' ordering.append((t,i)) if ordering: ordering.sort() required_prefix = _type_conv[ordering[0][0]] else: required_prefix = 'd' dtypechar = _inv_type_conv[required_prefix] # Default lookup: if ordering and arrays[ordering[0][1]].flags['FORTRAN']: # prefer Fortran code for leading array with column major order m1,m2 = flapack,clapack else: # in all other cases, C code is preferred m1,m2 = clapack,flapack if not _use_force_clapack: force_clapack = 0 funcs = [] m1_name = m1.__name__.split('.')[-1] m2_name = m2.__name__.split('.')[-1] for name in names: func_name = required_prefix + name func = getattr(m1,func_name,None) if func is None: func = getattr(m2,func_name) func.module_name = m2_name else: func.module_name = m1_name if force_clapack and m1 is flapack: func2 = getattr(m2,func_name,None) if func2 is not None: import new func_code = None # defined in exec exec(_colmajor_func_template % {'func_name':func_name}) func = new.function(func_code,{'clapack_func':func2},func_name) func.module_name = m2_name func.__doc__ = func2.__doc__ func.prefix = required_prefix func.dtypechar = dtypechar funcs.append(func) return tuple(funcs)
def func_with_new_name(func, newname): """Make a renamed copy of a function.""" f = new.function(func.func_code, func.func_globals, newname, func.func_defaults, func.func_closure) if func.func_dict: f.func_dict = {} f.func_dict.update(func.func_dict) return f
def with_name(f, name): try: f.__name__=name return f except (TypeError,AttributeError): return function( getattr(f,CODE), getattr(f,GLOBALS), name, getattr(f,DEFAULTS), getattr(f,CLOSURE) )
def compile(self, name, args=None, docstring=None, filename=None, firstlineno=0): # Generate the code object if args is None: args = ("context",) if filename is None: filename = "<ast-%d>" % xpathcompiler._nasts xpathcompiler._nasts += 1 code = self._graph.assemble(name, args, docstring, filename, firstlineno) # Make the function if 0: title = "%s (%s)" % (filename, name) print "--", title, "-" * (60 - len(title)) print ">>", docstring import dis dis.dis(code) return new.function(code, {"__lltrace__": 1}) return new.function(code, {})
def func(self): """Return a true Python function based on this function/code object""" c = self.code() f = new.function(c, self.func_globals, self.func_name, self.func_defaults or ()) f.func_dict = self.func_dict f.func_doc = self.func_doc #f.func_closure = self.func_closure return f
def _build_function(self, name): code_args = self.code_arguments[:] code_args[9] = name # code_args[8] = <modulename> codeobj = new.code(*code_args) return new.function(codeobj, { '__funcname__': name, '__builtins__': __builtins__ }, name)
def persistent_locals(f): """Function decorator to expose local variables after execution. Modify the function such that, at the exit of the function (regular exit or exceptions), the local dictionary is copied to a read-only function property 'locals'. This decorator wraps the function in a callable object, and modifies its bytecode by adding an external try...finally statement equivalent to the following: def f(self, *args, **kwargs): try: ... old code ... finally: self._locals = locals().copy() del self._locals['self'] """ # ### disassemble f f_code = bp.Code.from_code(f.func_code) # ### use bytecode injection to add try...finally statement around code finally_label = bp.Label() # try: code_before = (bp.SETUP_FINALLY, finally_label) # [original code here] # finally: code_after = [ (finally_label, None), # self._locals = locals().copy() (bp.LOAD_GLOBAL, 'locals'), (bp.CALL_FUNCTION, 0), (bp.LOAD_ATTR, 'copy'), (bp.CALL_FUNCTION, 0), (bp.LOAD_FAST, 'self'), (bp.STORE_ATTR, '_locals'), # del self._locals['self'] (bp.LOAD_FAST, 'self'), (bp.LOAD_ATTR, '_locals'), (bp.LOAD_CONST, 'self'), (bp.DELETE_SUBSCR, None), (bp.END_FINALLY, None), (bp.LOAD_CONST, None), (bp.RETURN_VALUE, None) ] f_code.code.insert(0, code_before) f_code.code.extend(code_after) # ### re-assemble f_code.args = ('self', ) + f_code.args func = new.function(f_code.to_code(), f.func_globals, f.func_name, f.func_defaults, f.func_closure) return PersistentLocalsFunction(func)
def __getattr__(self, name): blacklist = ['im_func', 'func_code', 'index_html'] if name.startswith('_') or name in blacklist: raise AttributeError(name) # Check if there is views/<self.__name__>.<name>.py in the theme, if not raise # noqa currentTheme = getCurrentTheme() if currentTheme is None: raise AttributeError(name) themeDirectory = queryResourceDirectory(THEME_RESOURCE_NAME, currentTheme) # noqa if themeDirectory is None: raise AttributeError(name) script = None scriptPath = "%s/%s.py" % (FRAGMENTS_DIRECTORY, self.__name__) if themeDirectory.isFile(scriptPath): script = themeDirectory.readFile(scriptPath) if 'def {0:}(self'.format(name) in script: script += '\n\nreturn {0:s}(self)'.format(name) else: script = None scriptPath = "%s/%s.%s.py" % (FRAGMENTS_DIRECTORY, self.__name__, name) if script is None and themeDirectory.isFile(scriptPath): script = themeDirectory.readFile(scriptPath) if script is None: raise AttributeError(name) # Set the default PythonScript bindings as globals script_globals = { 'script': self, 'context': self.context, 'container': Acquisition.aq_parent(self.context), 'traverse_subpath': '' } # Build re-usable restricted function components like in PythonScript try: code, g, defaults = prepare_restricted_function( 'self,*args,**kwargs', script or 'pass', name, scriptPath, script_globals.keys()) except SyntaxError: raise AttributeError(name) # Update globals g = g.copy() g.update(script_globals) g['__file__'] = scriptPath func = new.function(code, g, None, defaults) # Return the func as instancemethod return types.MethodType(func, self)
def get_cell_value(cell): def make_closure_that_returns_value(use_this_value): def closure_that_returns_value(): return use_this_value return closure_that_returns_value dummy_function = make_closure_that_returns_value(0) dummy_function_code = dummy_function.func_code our_function = new.function(dummy_function_code, {}, None, None, (cell,)) value_from_cell = our_function() return value_from_cell
def compile(self, name, args=None, docstring=None, filename=None, firstlineno=0): # Generate the code object if args is None: args = ('context',) if filename is None: filename = '<ast-%d>' % xpathcompiler._nasts xpathcompiler._nasts += 1 code = self._graph.assemble(name, args, docstring, filename, firstlineno) # Make the function if 0: title = '%s (%s)' % (filename, name) print '--', title, '-'*(60 - len(title)) print '>>', docstring import dis dis.dis(code) return new.function(code, {'__lltrace__': 1}) return new.function(code, {})
def real_fn(*arg, **kw): sys.exc_clear() fn_globals = dict(fn.func_globals) deb_obj = DebObj(deb_params, fn.func_name, '', filename, lineno) fn_globals['deb'] = deb_obj if deb_container is not None: deb_container.add(deb_obj) new_fn = new.function(fn.func_code, fn_globals, fn.func_name, fn.func_defaults) return new_fn(*arg, **kw)
def funct(a): strfunc = "\ def foo(): \ x = "+str(a)+"; return type(x)" co = compile ( strfunc, '', 'exec' ) ns = {} exec co in ns nfunc = new.function(ns["foo"].func_code, globals(), 'foo' ) globals()['foo'] = nfunc
def closure(func, locs = {}): """ Returns a function whose global namespace is a **copy of** *func*'s globals, augmented with the local variables of the calling function. This is a common requirement for functional programming. This can be duplicated in standard Python using default arguments, but it is generally more cumbersome. Note there is little reason for this function under Python 2.1, which provides this capability directly. Example: #A function which returns a function which returns 1 if an item is #in *sequence*, 0 otherwise def contained(sequence): def contained_helper(x): return x in sequence return closure(contained_helper) >>>lst = [1,2,3] >>>is123 = contained(lst) >>>is123(2) 1 >>> #An example of 'static' variables, somewhat like in C: def bindCallCount(func): callCount = ref(0) return closure(func) #Note this function uses a variable, callCount, that is not defined. def printAndIncrement(): print callCount.val callCount.val = callCount.val + 1 #But with closures, we can make this function work: >>>printAndInc = bindCallCount(printAndIncrement) >>>printAndInc() 0 >>>printAndInc() 1 >>> So callCount is preserved across function invocations, but is not taking up space in the module namespace. """ frame = getStackFrame().f_back if not locs: locs = frame.f_locals globs = {} globs.update(func.func_globals) globs.update(locs) newfunc = new.function(func.func_code, globs) globs[func.__name__] = newfunc return newfunc
def fake_import(fake_module): module_name = 'martiantest.fake.' + fake_module.__name__ module = new.module(module_name) module_name_parts = module_name.split('.') module.__file__ = '/' + '/'.join(module_name_parts) glob = {} for name in dir(fake_module): if name.startswith('__') and '.' not in name: continue obj = getattr(fake_module, name) glob[name] = obj try: obj = obj.im_func except AttributeError: pass __module__ = None try: __module__ == obj.__dict__.get('__module__') except AttributeError: try: __module__ = obj.__module__ except AttributeError: pass if __module__ is None or __module__ == '__builtin__': try: obj.__module__ = module.__name__ except AttributeError: pass setattr(module, name, obj) # provide correct globals for functions for name in dir(module): if name.startswith('__'): continue obj = getattr(module, name) try: code = obj.func_code new_func = new.function(code, glob, name) new_func.__module__ = module.__name__ setattr(module, name, new_func) glob[name] = new_func except AttributeError: pass if not 'martiantest' in sys.modules: sys.modules['martiantest'] = new.module('martiantest') sys.modules['martiantest.fake'] = new.module('martiantest.fake') sys.modules['martiantest'].fake = sys.modules['martiantest.fake'] sys.modules[module_name] = module setattr(sys.modules['martiantest.fake'], module_name.split('.')[-1], module) return module
def _make_wrapper_func (wrapper, func): """Return wrapper function with changed name """ name = func.__name__ + "_wrapper" c = wrapper.func_code newcode = new.code( c.co_argcount, c.co_nlocals, c.co_stacksize, c.co_flags, c.co_code, c.co_consts, c.co_names, c.co_varnames, "indigo core", name, 1, c.co_lnotab, c.co_freevars, c.co_cellvars ) new_wrapper = new.function(newcode, globals(), name=name, closure=wrapper.func_closure, argdefs=wrapper.func_defaults) return new_wrapper