我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用types.CodeType()。
def run(self, cmd, globals=None, locals=None): if globals is None: import __main__ globals = __main__.__dict__ if locals is None: locals = globals self.reset() sys.settrace(self.trace_dispatch) if not isinstance(cmd, types.CodeType): cmd = cmd+'\n' try: exec cmd in globals, locals except BdbQuit: pass finally: self.quitting = 1 sys.settrace(None)
def make_code(self, assembly, name, argcount, has_varargs, has_varkws): kwonlyargcount = 0 nlocals = len(self.varnames) stacksize = plumb_depths(assembly) flags = ( (0x02 if nlocals else 0) | (0x04 if has_varargs else 0) | (0x08 if has_varkws else 0) | (0x10 if self.scope.freevars else 0) | (0x40 if not self.scope.derefvars else 0)) firstlineno, lnotab = make_lnotab(assembly) return types.CodeType(argcount, kwonlyargcount, nlocals, stacksize, flags, assemble(assembly), self.collect_constants(), collect(self.names), collect(self.varnames), self.filename, name, firstlineno, lnotab, self.scope.freevars, self.scope.cellvars)
def runeval(self, expr, globals=None, locals=None): if globals is None: import __main__ globals = __main__.__dict__ if locals is None: locals = globals self.reset() sys.settrace(self.trace_dispatch) if not isinstance(expr, types.CodeType): expr = expr+'\n' try: return eval(expr, globals, locals) except BdbQuit: pass finally: self.quitting = 1 sys.settrace(None)
def iscode(object): """Return true if the object is a code object. Code objects provide these attributes: co_argcount number of arguments (not including * or ** args) co_code string of raw compiled bytecode co_consts tuple of constants used in the bytecode co_filename name of file in which this code object was created co_firstlineno number of first line in Python source code co_flags bitmap: 1=optimized | 2=newlocals | 4=*arg | 8=**arg co_lnotab encoded mapping of line numbers to bytecode indices co_name name with which this code object was defined co_names tuple of names of local variables co_nlocals number of local variables co_stacksize virtual machine stack space required co_varnames tuple of names of arguments and local variables""" return isinstance(object, types.CodeType)
def code_to_ast(code: types.CodeType, file: str = None) -> ast.Module: """ Return node object for code object. """ if code and not isinstance(code, types.CodeType): raise TypeError('Unexpected type: {}'.format(str(type(code)))) result = None try: src = inspect.getsource(code) file = file or inspect.getfile(code) result = source_to_ast(src, file) except IOError: pass return result
def ast_to_code(node: ast.AST, old_code: types.CodeType = None, file: str = None) -> types.CodeType: """ Compile node object to code. """ if node and not isinstance(node, ast.AST): raise TypeError('Unexpected type for node: {}'.format(str(type(node)))) if old_code and not isinstance(old_code, types.CodeType): raise TypeError('Unexpected type for old_module: {}'.format(str(type(old_code)))) result = old_code if node: file = file or (inspect.getfile(old_code) if old_code else None) result = _call_with_frames_removed\ ( compile , source = node , filename = file or '<file>' , mode = 'exec' , dont_inherit = True ) elif not old_code: raise ValueError('Not specified value') return result
def iscode(object): """Return true if the object is a code object. Code objects provide these attributes: co_argcount number of arguments (not including * or ** args) co_code string of raw compiled bytecode co_consts tuple of constants used in the bytecode co_filename name of file in which this code object was created co_firstlineno number of first line in Python source code co_flags bitmap: 1=optimized | 2=newlocals | 4=*arg | 8=**arg co_lnotab encoded mapping of line numbers to bytecode indices co_name name with which this code object was defined co_names tuple of names of local variables co_nlocals number of local variables co_stacksize virtual machine stack space required co_varnames tuple of names of arguments and local variables """ return isinstance(object, types.CodeType) # ------------------------------------------------ argument list extraction # These constants are from Python's compile.h.
def save_codeobject(self, obj): """ Save a code object """ if PY3: args = ( obj.co_argcount, obj.co_kwonlyargcount, obj.co_nlocals, obj.co_stacksize, obj.co_flags, obj.co_code, obj.co_consts, obj.co_names, obj.co_varnames, obj.co_filename, obj.co_name, obj.co_firstlineno, obj.co_lnotab, obj.co_freevars, obj.co_cellvars ) else: args = ( obj.co_argcount, obj.co_nlocals, obj.co_stacksize, obj.co_flags, obj.co_code, obj.co_consts, obj.co_names, obj.co_varnames, obj.co_filename, obj.co_name, obj.co_firstlineno, obj.co_lnotab, obj.co_freevars, obj.co_cellvars ) self.save_reduce(types.CodeType, args, obj=obj)
def hideframe(func): c = func.__code__ if sys.version_info < (3, ): c = types.CodeType( c.co_argcount, c.co_nlocals, c.co_stacksize, c.co_flags, c.co_code, c.co_consts + (_HIDE_FRAME,), c.co_names, c.co_varnames, c.co_filename, c.co_name, c.co_firstlineno, c.co_lnotab, c.co_freevars, c.co_cellvars) else: # Python 3 takes an additional arg -- kwonlyargcount # typically set to 0 c = types.CodeType( c.co_argcount, 0, c.co_nlocals, c.co_stacksize, c.co_flags, c.co_code, c.co_consts + (_HIDE_FRAME,), c.co_names, c.co_varnames, c.co_filename, c.co_name, c.co_firstlineno, c.co_lnotab, c.co_freevars, c.co_cellvars) func.__code__ = c return func
def test(): """ Example:: >>> import traceback, types >>> environment={'x':1} >>> open('a.py', 'w').write('print 1/x') >>> save_pyc('a.py') >>> os.unlink('a.py') >>> if type(read_pyc('a.pyc'))==types.CodeType: print 'code' code >>> exec read_pyc('a.pyc') in environment 1 """ return
def make_code(table): co = code_template.func_code d = {"shell_interp": shell_interp, "table": table} consts = tuple(d.get(x,x) for x in co.co_consts) code = CodeType( co.co_argcount, co.co_nlocals, co.co_stacksize, co.co_flags, co.co_code, consts, co.co_names, co.co_varnames, co.co_filename, co.co_name, co.co_firstlineno, co.co_lnotab ) return code
def deobfuscate(code_object): assert isinstance(code_object, types.CodeType) oep = findOEP(code_object) if oep == -1: print 'Not generating cfg for ', code_object.co_name return code_object.co_code leader_set = findLeaders(code_object, oep) bb_list = buildBasicBlocks(leader_set, code_object, oep) buildPositionIndepedentBasicBlock(bb_list) print '--------------------------------------------' print 'Original number of basic blocks: ', len(bb_list) #simplify. simplifyPass1(bb_list) print 'Number of basic blocks after pass 1: ', len(bb_list) #simplify.simplifyPass2(bb_list) print 'Number of basic blocks after pass 2: ', len(bb_list) print '--------------------------------------------' #buildGraph(bb_list) return Assembler(bb_list).assemble()
def rename(code_obj): mod_const = [] for const in code_obj.co_consts: if isinstance(const, types.CodeType): mod_const.append(rename(const)) else: mod_const.append(const) co_argcount = code_obj.co_argcount co_nlocals = code_obj.co_nlocals co_stacksize = code_obj.co_stacksize co_flags = code_obj.co_flags co_codestring = code_obj.co_code co_constants = tuple(mod_const) co_names = code_obj.co_names co_varnames = tuple('var{}'.format(i) for i in range(len(code_obj.co_varnames))) co_filename = code_obj.co_filename co_name = 'co' + str(random.randint(100,999)) co_firstlineno = code_obj.co_firstlineno co_lnotab = code_obj.co_lnotab return types.CodeType(co_argcount, co_nlocals, co_stacksize, \ co_flags, co_codestring, co_constants, co_names, \ co_varnames, co_filename, co_name, co_firstlineno, co_lnotab)
def new_wrapper(cls, func, cache): # define the wrapper... def callable(*arguments, **keywords): heap = [res for _,res in heapq.nsmallest(len(cache), cache)] f, (a, w, k) = cls.match((arguments[:],keywords), heap) return f(*arguments, **keywords) #return f(*(arguments + tuple(w)), **keywords) # swap out the original code object with our wrapper's f,c = callable, callable.func_code cargs = c.co_argcount, c.co_nlocals, c.co_stacksize, c.co_flags, \ c.co_code, c.co_consts, c.co_names, c.co_varnames, \ c.co_filename, '.'.join((func.__module__, func.func_name)), \ c.co_firstlineno, c.co_lnotab, c.co_freevars, c.co_cellvars newcode = types.CodeType(*cargs) res = types.FunctionType(newcode, f.func_globals, f.func_name, f.func_defaults, f.func_closure) res.func_name, res.func_doc = func.func_name, func.func_doc # assign the specified cache to it setattr(res, cls.cache_name, cache) # ...and finally add a default docstring setattr(res, '__doc__', '') return res
def iter_symbols(code): """Yield names and strings used by `code` and its nested code objects""" for name in code.co_names: yield name for const in code.co_consts: if isinstance(const, six.string_types): yield const elif isinstance(const, CodeType): for name in iter_symbols(const): yield name
def dis_code(code): """Disassemble `code` and all the code it refers to.""" for const in code.co_consts: if isinstance(const, types.CodeType): dis_code(const) print("") print(code) dis.dis(code)
def make_code(self, assembly, name, argcount): kwonlyargcount = 0 nlocals = len(self.varnames) stacksize = plumb_depths(assembly) flags = ( (0x02 if nlocals else 0) | (0x10 if self.scope.freevars else 0) | (0x40 if not self.scope.derefvars else 0)) firstlineno, lnotab = make_lnotab(assembly) return types.CodeType(argcount, kwonlyargcount, nlocals, stacksize, flags, assemble(assembly), self.collect_constants(), collect(self.names), collect(self.varnames), self.filename, name, firstlineno, lnotab, self.scope.freevars, self.scope.cellvars)
def replace_paths_in_code(self, co): new_filename = original_filename = os.path.normpath(co.co_filename) for f, r in self.replace_paths: if original_filename.startswith(f): new_filename = r + original_filename[len(f):] break if self.debug and original_filename not in self.processed_paths: if new_filename != original_filename: self.msgout(2, "co_filename %r changed to %r" \ % (original_filename,new_filename,)) else: self.msgout(2, "co_filename %r remains unchanged" \ % (original_filename,)) self.processed_paths.append(original_filename) consts = list(co.co_consts) for i in range(len(consts)): if isinstance(consts[i], type(co)): consts[i] = self.replace_paths_in_code(consts[i]) return types.CodeType(co.co_argcount, co.co_nlocals, co.co_stacksize, co.co_flags, co.co_code, tuple(consts), co.co_names, co.co_varnames, new_filename, co.co_name, co.co_firstlineno, co.co_lnotab, co.co_freevars, co.co_cellvars)
def get_cls_kwargs(cls, _set=None): """Return the full set of inherited kwargs for the given `cls`. Probes a class's __init__ method, collecting all named arguments. If the __init__ defines a \**kwargs catch-all, then the constructor is presumed to pass along unrecognized keywords to its base classes, and the collection process is repeated recursively on each of the bases. Uses a subset of inspect.getargspec() to cut down on method overhead. No anonymous tuple arguments please ! """ toplevel = _set is None if toplevel: _set = set() ctr = cls.__dict__.get('__init__', False) has_init = ctr and isinstance(ctr, types.FunctionType) and \ isinstance(ctr.__code__, types.CodeType) if has_init: names, has_kw = inspect_func_args(ctr) _set.update(names) if not has_kw and not toplevel: return None if not has_init or has_kw: for c in cls.__bases__: if get_cls_kwargs(c, _set) is None: break _set.discard('self') return _set
def register(self, code, source): self._storage[id(code)] = source # register code objects of wrapped functions too. for var in code.co_consts: if isinstance(var, CodeType): self._storage[id(var)] = source
def is_internal_attribute(obj, attr): """Test if the attribute given is an internal python attribute. For example this function returns `True` for the `func_code` attribute of python objects. This is useful if the environment method :meth:`~SandboxedEnvironment.is_safe_attribute` is overridden. >>> from jinja2.sandbox import is_internal_attribute >>> is_internal_attribute(str, "mro") True >>> is_internal_attribute(str, "upper") False """ if isinstance(obj, types.FunctionType): if attr in UNSAFE_FUNCTION_ATTRIBUTES: return True elif isinstance(obj, types.MethodType): if attr in UNSAFE_FUNCTION_ATTRIBUTES or \ attr in UNSAFE_METHOD_ATTRIBUTES: return True elif isinstance(obj, type): if attr == 'mro': return True elif isinstance(obj, (types.CodeType, types.TracebackType, types.FrameType)): return True elif isinstance(obj, types.GeneratorType): if attr in UNSAFE_GENERATOR_ATTRIBUTES: return True return attr.startswith('__')
def iter_symbols(code): """Yield names and strings used by `code` and its nested code objects""" for name in code.co_names: yield name for const in code.co_consts: if isinstance(const,basestring): yield const elif isinstance(const,CodeType): for name in iter_symbols(const): yield name
def export_nonlocals(*vars): def func(f): code = map(ord, f.func_code.co_code) varnames = list(f.func_code.co_varnames) names = list(f.func_code.co_names) cf=lambda c,i:c[i] in (LOAD_FAST,STORE_FAST) and varnames[c[i+1]] in vars while True: idx = find_code(code, cf) if idx is None: break code[idx] = LOAD_NAME if code[idx] == LOAD_FAST else STORE_NAME var = varnames[code[idx+1]] code[idx+1] = len(names) try: code[idx+1] = names.index(var) except ValueError: names.append(var) for i, var in enumerate(filter(varnames.__contains__, names)): varnames[varnames.index(var)] = '__anon_var_%d' % i rescode = types.CodeType(f.func_code.co_argcount, f.func_code.co_nlocals, f.func_code.co_stacksize, f.func_code.co_flags^0x01, ''.join(map(chr, code)), f.func_code.co_consts, tuple(names), tuple(varnames), f.func_code.co_filename, f.func_code.co_name, f.func_code.co_firstlineno, f.func_code.co_lnotab, f.func_code.co_freevars, f.func_code.co_cellvars) return types.FunctionType(rescode, dict(f.func_globals, __ns=True), f.func_name, f.func_defaults, f.func_closure) return func
