def get_object(self, g=None): # try to load function back into its module: if not self.module.startswith('__'): __import__(self.module) g = sys.modules[self.module].__dict__ if g is None: g = {} if self.defaults: defaults = tuple(uncan(cfd, g) for cfd in self.defaults) else: defaults = None if self.kwdefaults: kwdefaults = uncan_dict(self.kwdefaults) else: kwdefaults = None if self.annotations: annotations = uncan_dict(self.annotations) else: annotations = {} if self.closure: closure = tuple(uncan(cell, g) for cell in self.closure) else: closure = None newFunc = FunctionType(self.code, g, self.__name__, defaults, closure) if kwdefaults: newFunc.__kwdefaults__ = kwdefaults if annotations: newFunc.__annotations__ = annotations return newFunc
def chained_function(meta, func, mod): d = ModuleChainedDict(mod.__dict__, func.__globals__) newfunc = FunctionType(func.__code, d) newfunc.__doc__ = func.__doc__ newfunc.__defaults__ = newfunc.__defaults__ newfunc.__kwdefaults__ = func.__kwdefaults__ return newfunc
def copy_func(f: FunctionType, name, defaults, signature: Signature): """ Makes exact copy of a function object with given name and defaults """ new_defaults = [] kw_only_defaults = f.__kwdefaults__.copy() if f.__kwdefaults__ else {} for key, param in signature.parameters.items(): if param.kind is param.KEYWORD_ONLY: if key in defaults: kw_only_defaults[key] = defaults.pop(key) elif key in defaults: new_defaults.append(defaults.pop(key)) elif param.default is not param.empty: new_defaults.append(param.default) new_func = FunctionType( code=copy_code(f.__code__, co_name=name), globals=f.__globals__, name=name, argdefs=tuple(new_defaults), closure=f.__closure__, ) new_func.__kwdefaults__ = kw_only_defaults new_func.__dict__.update(f.__dict__) return new_func
def hax(target: T) -> T: if isinstance(target, CodeType): return cast(T, _hax(target)) if isinstance(target, FunctionType): new = FunctionType( _hax(target.__code__), target.__globals__, target.__name__, target.__defaults__, target.__closure__, ) if target.__annotations__: new.__annotations__ = target.__annotations__.copy() if target.__kwdefaults__ is not None: new.__kwdefaults__ = target.__kwdefaults__.copy() if target.__dict__: new.__dict__ = target.__dict__.copy() return cast(T, new) raise TypeError(f"HAX doesn't support this! Got type {type(target)!r}.")
def copy_func(func: FunctionType, deep: bool = False) -> FunctionType: """Copy a function as a different object. Args: func: Function object to be copied. deep: If ``True``, mutable attributes of ``func`` are deep-copied. Returns: Function as a different object from the original one. """ copied = FunctionType( func.__code__, func.__globals__, func.__name__, func.__defaults__, func.__closure__, ) # mutable attributes are copied by the given method copier = deepcopy if deep else copy copied.__annotations__ = copier(func.__annotations__) copied.__dict__ = copier(func.__dict__) copied.__kwdefaults__ = copier(func.__kwdefaults__) # immutable attributes are not copied (just assigned) copied.__doc__ = func.__doc__ copied.__module__ = func.__module__ copied.__name__ = func.__name__ copied.__qualname__ = func.__qualname__ return copied
def loads_function(s): '''Restores a function serialized with :func:`dumps_function`.''' if PY2: name, code, globals_, defaults, closure, func_dict, doc = loads(s) else: name, code, globals_, defaults, closure, func_dict, doc, qualname, kwdefaults, annotations = loads( s) code = marshal.loads(code) for k, v in globals_.items(): if isinstance(v, Module): globals_[k] = v.mod if closure is not None: import ctypes ctypes.pythonapi.PyCell_New.restype = ctypes.py_object ctypes.pythonapi.PyCell_New.argtypes = [ctypes.py_object] closure = tuple(ctypes.pythonapi.PyCell_New(c) for c in closure) globals_['__builtins__'] = __builtins__ r = FunctionType(code, globals_, name, defaults, closure) r.__dict__ = func_dict r.__doc__ = doc if not PY2: r.__qualname__ = qualname r.__kwdefaults__ = kwdefaults r.__annotations__ = annotations return r
def chained_function(meta, func, mod): d = _NSChainedDict(mod.__dict__, func.__globals__) newfunc = FunctionType(func.__code__, d) newfunc.__doc__ = func.__doc__ newfunc.__defaults__ = func.__defaults__ newfunc.__kwdefaults__ = func.__kwdefaults__ return newfunc
def buildFunction(baseFunc, code=None, glbls=None, name=None, defaults=None, kwdefaults=None, closure=None, annotations=None, doc=None, dct=None): resf = None def _f(): pass if hasattr(_f, 'func_code'): # Python 2.x resf = FunctionType(code or baseFunc.func_code, glbls or baseFunc.func_globals, name or baseFunc.func_name, defaults or baseFunc.func_defaults, closure or baseFunc.func_closure) resf.func_dict = dct or baseFunc.func_dict resf.func_doc = doc or baseFunc.func_doc else: # Python 3.x resf = FunctionType(code or baseFunc.__code__, glbls or baseFunc.__globals__, name or baseFunc.__name__, defaults or baseFunc.__defaults__, closure or baseFunc.__closure__) resf.__kwdefaults__ = kwdefaults or baseFunc.__kwdefaults__ resf.__annotations__ = annotations or baseFunc.__annotations__ resf.__dict__ = dct or baseFunc.__dict__ resf.__doc__ = doc or baseFunc.__doc__ return resf
def _clone_function(f): '''Make a copy of a function''' # based on http://stackoverflow.com/a/13503277/2289509 new_f = FunctionType(f.__code__, f.__globals__, name=f.__name__, argdefs=f.__defaults__, closure=f.__closure__) new_f = update_wrapper(new_f, f) new_f.__kwdefaults__ = f.__kwdefaults__ return new_f
def copy_func(f: Callable) -> Callable: """Duplicate a function object""" g = FunctionType(f.__code__, f.__globals__, name=f.__name__, argdefs=f.__defaults__, closure=f.__closure__) g = update_wrapper(g, f) g.__kwdefaults__ = f.__kwdefaults__ return g
def _function_constructor(code, fglobals, name, argdefs, closure, kwdefaults, fdict, annotations, qualname, doc, module): func = FunctionType(code, fglobals, name, argdefs, closure) func.__kwdefaults__ = kwdefaults func.__dict__ = fdict func.__annotations__ = annotations func.__qualname__ = qualname func.__doc__ = doc func.__module__ = module return func
def alias(name: str, doc: str, fun: Callable[..., Any]) -> Callable[..., Any]: # Adapted from https://stackoverflow.com/questions/13503079/how-to-create-a-copy-of-a-python-function# # See also help(type(lambda: 0)) alias = FunctionType(fun.__code__, fun.__globals__, name=name, argdefs=fun.__defaults__, closure=fun.__closure__) alias = update_wrapper(alias, fun) alias.__kwdefaults__ = fun.__kwdefaults__ alias.__doc__ = doc return alias
def conform(self, obj1: types.FunctionType, obj2: types.FunctionType): fv1 = obj1.__code__.co_freevars fv2 = obj2.__code__.co_freevars if fv1 != fv2: msg = ( f"Cannot replace closure `{obj1.__name__}` because the free " f"variables changed. Before: {fv1}; after: {fv2}." ) if ("__class__" in (fv1 or ())) ^ ("__class__" in (fv2 or ())): msg += " Note: The use of `super` entails the `__class__` free variable." raise ConformException(msg) obj1.__code__ = obj2.__code__ obj1.__defaults__ = obj2.__defaults__ obj1.__kwdefaults__ = obj2.__kwdefaults__
def change_func_globals(f, globals): """Based on https://stackoverflow.com/a/13503277/2988730 (@unutbu)""" # __globals__ is a private member of the function class # so we have to copy the function, f, all of its member, except f.__globals__ g = FunctionType( f.__code__, globals, name=f.__name__, argdefs=f.__defaults__, closure=f.__closure__, ) g = functools.update_wrapper(g, f) g.__kwdefaults__ = copy.copy(f.__kwdefaults__) return g
def alias(name: str, doc: str, fun: Callable[..., Any]) -> Callable[..., Any]: # Adapted from https://stackoverflow.com/questions/13503079/how-to-create-a-copy-of-a-python-function# # See also help(type(lambda: 0)) _fun = cast(FunctionType, fun) args = (_fun.__code__, _fun.__globals__) kwargs = { 'name': name, 'argdefs': _fun.__defaults__, 'closure': _fun.__closure__ } alias = FunctionType(*args, **kwargs) # type: ignore alias = cast(FunctionType, update_wrapper(alias, _fun)) alias.__kwdefaults__ = _fun.__kwdefaults__ alias.__doc__ = doc return alias
def alias(name: str, doc: str, fun: Callable[_P, _T]) -> Callable[_P, _T]: # Adapted from # https://stackoverflow.com/questions/13503079/how-to-create-a-copy-of-a-python-function# # See also help(type(lambda: 0)) _fun = cast(FunctionType, fun) args = (_fun.__code__, _fun.__globals__) kwargs = { "name": name, "argdefs": _fun.__defaults__, "closure": _fun.__closure__ } alias_ = FunctionType(*args, **kwargs) # type: ignore alias_ = update_wrapper(alias_, _fun) alias_.__kwdefaults__ = _fun.__kwdefaults__ alias_.__doc__ = doc alias_.__annotations__ = _fun.__annotations__ return alias_
def func2not_implemented(func): from types import FunctionType code = func.__code__ code = code2not_implemented_code(code) ## | function(code, globals[, name[, argdefs[, closure]]]) ## | ## | Create a function object from a code object and a dictionary. ## | The optional name string overrides the name from the code object. ## | The optional argdefs tuple specifies the default argument values. ## | The optional closure tuple supplies the bindings for free variables. # constructor: no __kwdefaults__?? new_func = FunctionType(code, func.__globals__, func.__name__, func.__defaults__) new_func.__kwdefaults__ = func.__kwdefaults__ return new_func
def copy_function(fn) -> Callable: """ Create a clone of a given function :param fn: Function to copy :return: New function with the same attributes but with different id """ """Based on http://stackoverflow.com/a/6528148/190597 (Glenn Maynard)""" g = FunctionType( fn.__code__, fn.__globals__, name=fn.__name__, argdefs=fn.__defaults__, closure=fn.__closure__, ) g.__kwdefaults__ = deepcopy(fn.__kwdefaults__) g.__annotations__ = deepcopy(fn.__annotations__) return g
def __init_subclass__(cls): super().__init_subclass__() # override signature of __new__ to match __init__ so IDEs and Sphinx # will display the correct signature new = FunctionType( # almost exact copy of __new__ cls.__new__.__code__, cls.__new__.__globals__, name=cls.__new__.__name__, argdefs=cls.__new__.__defaults__, closure=cls.__new__.__closure__) new = functools.update_wrapper(new, cls.__new__) # update further new.__kwdefaults__ = cls.__init__.__kwdefaults__ # fill in kwdefaults sig = cls._init_signature # override signature to look like init sig = sig.replace(parameters=[inspect.Parameter("cls", 0)] + list(sig.parameters.values())) new.__signature__ = sig # set __new__ with copied & modified version cls.__new__ = new # ------------------- # Parameters # Get parameters that are still Parameters, either in this class or above. parameters = [ n for n in cls.__parameters__ if isinstance(getattr(cls, n), Parameter) ] # Add new parameter definitions parameters += [ n for n, v in cls.__dict__.items() if (n not in parameters and not n.startswith("_") and isinstance(v, Parameter)) ] # reorder to match signature ordered = [ parameters.pop(parameters.index(n)) for n in cls._init_signature.parameters.keys() if n in parameters ] parameters = ordered + parameters # place "unordered" at the end cls.__parameters__ = tuple(parameters) # ------------------- # register as a Cosmology subclass _COSMOLOGY_CLASSES[cls.__qualname__] = cls
def modfuncglobals(func, *ds, **kw): '''Add globals to a function.''' dp = dictproxy() newfunc = FunctionType(func.__code__, dictproxy(dp, func.__globals__)) newfunc.__name__ = func.__name__ newfunc.__doc__ = func.__doc__ newfunc.__defaults__ = func.__defaults__ newfunc.__kwdefaults__ = func.__kwdefaults__ newfunc.__scopes__ = dp.maps def add(*ds, **kw): for d in ds[::-1]: newfunc.__scopes__.insert(0, d) if kw: newfunc.add(kw) return newfunc newfunc.add = add newfunc.add(*ds, **kw) return newfunc
def import_function(functup, globals=None, def_=True): name, modname, defaults, kwdefaults, codetup = functup if globals is None: try: mod = __import__(modname, None, None, "*") except ImportError: mod = __import__("__main__", None, None, "*") globals = mod.__dict__ # function globals must be real dicts, sadly: if isinstance(globals, netref.BaseNetref): from rpyc.utils.classic import obtain globals = obtain(globals) globals.setdefault('__builtins__', __builtins__) codeobj = _import_codetup(codetup) funcobj = FunctionType(codeobj, globals, name, defaults) if kwdefaults is not None: funcobj.__kwdefaults__ = {t[0]: t[1] for t in kwdefaults} if def_: globals[name] = funcobj return funcobj
def loads_function(s): '''Restores a function serialized with :func:`dumps_function`.''' name, code, globals_, defaults, closure, func_dict, doc, qualname, kwdefaults, annotations = loads(s) code = marshal.loads(code) for k, v in globals_.items(): if isinstance(v, Module): globals_[k] = v.mod if closure is not None: import ctypes ctypes.pythonapi.PyCell_New.restype = ctypes.py_object ctypes.pythonapi.PyCell_New.argtypes = [ctypes.py_object] closure = tuple(ctypes.pythonapi.PyCell_New(c) for c in closure) globals_['__builtins__'] = __builtins__ r = FunctionType(code, globals_, name, defaults, closure) r.__dict__ = func_dict r.__doc__ = doc r.__qualname__ = qualname r.__kwdefaults__ = kwdefaults r.__annotations__ = annotations return r
def copy_function(func, global_ctx=None): """ Copy the function, with given base global_ctx, and register the result function into the given base ctx. References ---------- 1. https://stackoverflow.com/a/13503277/5080177 """ if global_ctx is None: global_ctx = func.__globals__ fn = FunctionType( func.__code__, global_ctx, name=func.__name__, argdefs=func.__defaults__, closure=func.__closure__, ) # functools.update_wrapper would update all the metadata other then __kwdefaults__ fn.__kwdefaults__ = copy.copy(func.__kwdefaults__) return functools.update_wrapper(fn, func)
def func2not_implemented(func): sig_str = func2clean_signature_str(func) if sig_str not in cache__sig_str2code: code = signature_str2not_implemented_func(sig_str).__code__ cache__sig_str2code[sig_str] = code # code really depends on sig_str #cache__not_implemented_codes.add(code) #print('cache__not_implemented_codes', len(cache__not_implemented_codes)) else: code = cache__sig_str2code[sig_str] code_without_freevars = _replace_codestring(func.__code__, code) new = FunctionType(code_without_freevars, globals()) new.__dict__.update(vars(func)) new.__defaults__ = func.__defaults__ new.__kwdefaults__ = func.__kwdefaults__ new.__doc__ = func.__doc__ new.__name__ = func.__name__ new.__qualname__ = func.__qualname__ new.__module__ = func.__module__ new.__annotations__ = func.__annotations__ new.__dict__ = dict(func.__dict__) return new set_func_not_implemented(func) return func
def trace_function(self, func): # type: (FunctionType) -> FunctionType """ Returns a version of the passed function with the AST modified to trigger the tracing hooks. """ if not isinstance(func, FunctionType): raise ValueError('You can only trace user-defined functions. ' 'The birdseye decorator must be applied first, ' 'at the bottom of the list.') try: if inspect.iscoroutinefunction(func) or inspect.isasyncgenfunction( func): raise ValueError('You cannot trace async functions') except AttributeError: pass if is_lambda(func): raise ValueError('You cannot trace lambdas') filename = inspect.getsourcefile(func) # type: str if is_ipython_cell(filename): # noinspection PyPackageRequirements from IPython import get_ipython import linecache flags = get_ipython().compile.flags source = ''.join(linecache.cache[filename][2]) else: source = read_source_file(filename) flags = 0 # We compile the entire file instead of just the function source # because it can contain context which affects the function code, # e.g. enclosing functions and classes or __future__ imports traced_file = self.compile(source, filename, flags) if func.__dict__: raise ValueError('The birdseye decorator must be applied first, ' 'at the bottom of the list.') # Then we have to recursively search through the newly compiled # code to find the code we actually want corresponding to this function code_options = [] # type: List[CodeType] def find_code(root_code): # type: (CodeType) -> None for const in root_code.co_consts: # type: CodeType if not inspect.iscode(const): continue matches = (const.co_firstlineno == func.__code__.co_firstlineno and const.co_name == func.__code__.co_name) if matches: code_options.append(const) find_code(const) find_code(traced_file.code) if len(code_options) > 1: # Currently lambdas aren't allowed anyway, but should be in the future assert is_lambda(func) raise ValueError( "Failed to trace lambda. Convert the function to a def.") new_func_code = code_options[0] # type: CodeType # Give the new function access to the hooks # We have to use the original __globals__ and not a copy # because it's the actual module namespace that may get updated by other code func.__globals__.update(self._trace_methods_dict(traced_file)) # http://stackoverflow.com/a/13503277/2482744 # noinspection PyArgumentList new_func = FunctionType(new_func_code, func.__globals__, func.__name__, func.__defaults__, func.__closure__) update_wrapper(new_func, func) # type: FunctionType if PY3: new_func.__kwdefaults__ = getattr(func, '__kwdefaults__', None) new_func.traced_file = traced_file return new_func
def patched_function(function): new_function = FunctionType(six.get_function_code(function), globals()) if six.PY3: new_function.__kwdefaults__ = function.__kwdefaults__ new_function.__defaults__ = function.__defaults__ return new_function
def make_function( code: CodeType, globals_: T.Any, name: str, signature: _FullerSig, docstring: str = None, closure: T.Any = None, qualname: str = None, # options _add_signature: bool = False, ): r"""Make a function with a specified signature and docstring. This is pure python and may not make the fastest functions Parameters ---------- code : code the .__code__ method of a function globals_ : Any name : str signature : Signature inspect.Signature converted to utilipy.Signature docstring : str closure : Any qualname : str Returns ------- function: Callable the created function Other Parameters ---------------- \_add_signature : bool Whether to add `signature` as ``__signature__``. .. todo:: check how signature and closure relate __qualname__ """ if not isinstance(signature, _FullerSig): # not my custom signature signature = _FullerSig( parameters=signature.parameters.values(), return_annotation=signature.return_annotation, # docstring=docstring # not yet implemented ) # else: # pass # make function function = FunctionType( code, globals_, name=name, argdefs=signature.defaults, closure=closure ) # assign properties not (properly) handled by FunctionType function.__kwdefaults__ = signature.__kwdefaults__ function.__annotations__ = signature.__annotations__ function.__doc__ = docstring if qualname is not None: function.__qualname__ = qualname if _add_signature: function.__signature__ = signature.__signature__ # classical signature return function
def f_replace(f, *, code=None, closure=None): new_f = FunctionType(code or f.__code__, f.__globals__, f.__name__, f.__defaults__, closure or f.__closure__) new_f.__kwdefaults__ = f.__kwdefaults__ return new_f
def rebuild_func( func, cls=None, *wrappers, defaults_copy=None, kwdefaults_copy=None, dict_copy=None, closure_copy=None, global_ns=None, name=None, qualname=None, module=False, doc=False, annotations=False, ): """Create a copy of `func` that can be used as a method by any `cls` The main perk is giving a `cls` the ability to use *any* Python `function` as a bound method, regardless of where it was defined. In other words, it doesn't matter if a function was defined in the global scope, another module, or in the body of another class. Most importantly, functions that use zero-argument super will behave exactly the same as if they had been defined in `cls`. Unfortunately, there is one limitation. Wrapped functions not defined in the scope of a class body will not be able to use zero argument super. If they are wrapped *after* being bound with this function, they should have no problem working For convenience, any *wrappers provided will be applied after binding in the same order as decorator syntax, top to bottom or right to left ie. wrappers *(a, b ,c) will be equivalent to a(b(c(func))) There are nearly limitless uses for this black magic, but some good examples are the ability to make true deepcopies of functions, changing default/kwonly defaults, and tricking functions into using global references to objects not in the module it was defined in. To simplify the application of making true deepcopies of functions, which requires deepcopying of the original function's mutable attributes: __defaults__, __kwdefaults__, __dict__, and __closure__, the arguments `defaults_copy`, `kwdefaults_copy, `dict_copy`, and `closure_copy`, respectively, accept a callable that takes a single argument (the object to be copied) and returns an object of the same type (and length if applicable) to the original. If `defaults_copy` and `kwdefaults_copy` return None, the new function will no longer have default values. Otherwise, shallow copies of __defaults__, __kwdefaults__, and __dict__ are used, along with a deepcopy of __closure__. Parameters: :: `defaults_copy` called as defaults_copy(func.__defaults__) to replace `func.__defaults__`, the attribute that stores a tuple containing the default values of positional arguments. Removes default positional arguments entirely if it returns None :: `kwdefaults_copy` called as kwdefaults_copy(func.__kwdefaults__) to replace `func.__kwdefaults__`, the attribute that stores a mapping containing the default values of keyword only arguments. Removes default kwonly arguments entirely if it returns None :: `dict_copy` called as dict_copy(func.__dict__) to replace `func.__dict__` :: `closure_copy` called as closure_copy(func.__closure__) to replace `func.__closure__`, the attribute that stores references to any nonlocal names used by `func` :: `global_ns` used to replace func.__globals__ Will raise NameError if it doesn't contain all global references used by `func`. :: `name` a string that replaces func.__name__ :: `qualname` if None, will generate a new __qualname__ automatically, which depends on the values in `name`, `func`, and `cls` Otherwise, a string :: `module` can be any type and is used to replace `func.__module__` :: `doc` can be any type and is used to replace `func.__doc__` :: `annotations` None to clear or mapping to replace `func.__annotations__` By default is a shallow copy of `func.__annotations__` """ # validate func if not is_func(func): raise TypeError('func must be function object') else: f = func # validate cls if cls is None: class_was_not_none = False elif not is_heap_type(cls): raise TypeError('cls must be None or a Python class') else: class_was_not_none = True # validate defaults_copy defaults = f.__defaults__ if defaults_copy is None: defaults = None if defaults is None else tuple_copy(defaults) elif not callable(defaults_copy): raise TypeError('defaults_copy must be a callable') else: defaults = defaults_copy(defaults) # validate kwdefaults_copy kwdefaults = f.__kwdefaults__ if kwdefaults_copy is None: kwdefaults = None if kwdefaults is None else {**kwdefaults} elif not callable(kwdefaults_copy): raise TypeError('kwdefaults_copy must be a callable') else: kwdefaults = kwdefaults_copy(kwdefaults) # validate dict_copy new_dict = descriptor_getattr(f, '__dict__') if dict_copy is None: new_dict = {**new_dict} elif not callable(dict_copy): raise TypeError('dict_copy must be a callable') else: new_dict = dict_copy(new_dict) # validate closure_copy closure = f.__closure__ if closure_copy is None: if is_tuple(closure): closure = deepcopy_closure(closure) elif not callable(closure_copy): raise TypeError('closure_copy must be a callable') else: closure = closure_copy(closure) # validate name if name is None: name = f.__name__ elif not is_str(name): raise TypeError('function __name__ must be a string') # validate qualname if qualname is None: qualname = f'{cls.__name__}.{name}' if class_was_not_none else name elif not is_str(qualname): raise TypeError('function __qualname__ must be a string') # validate annotations f_annotations = f.__annotations__ if annotations is False: annotations = None if f_annotations is None else {**f_annotations} elif not is_mapping(annotations): raise TypeError('annotations must be None or a mapping') # validate global_ns sentinel = object() if global_ns is None: global_ns = f.__globals__ elif not is_dict(global_ns): raise TypeError('function __globals__ must be a dict') builtins = global_ns.get('__builtins__', sentinel) if builtins is sentinel: builtin_ns = {} elif is_dict(builtins): builtin_ns = builtins # the only time __builtins__ can be a module is if it IS builtins elif builtins is _builtins: builtin_ns = builtins.__dict__ else: raise TypeError('f.__globals__["__builtins__"] must be a dict' f'or the "builtins" module, not {builtins!r}') missing = set() code = f.__code__ co_freevars = code.co_freevars co_flags = code.co_flags co_names = code.co_names co_code = code.co_code for co_name in co_names: if iskeyword(co_name): continue ob = global_ns.get(co_name, sentinel) if ob is sentinel: ob = builtin_ns.get(co_name, sentinel) if ob is sentinel: if class_was_not_none and co_name == '__class__': continue missing.add(co_name) module = f.__module__ if module is False else module doc = f.__doc__ if doc is False else module if class_was_not_none: has_classcell = 'super' in co_names # replace LOAD_GLOBAL('__class__') opcodes with LOAD_DEREF('__class__') if '__class__' in co_names: j = co_names.index('__class__') #co_names = co_names[:j] + co_names[j+1:] bytecode = bytearray(co_code) for instr in dis.Bytecode(code): if instr.opname == 'LOAD_GLOBAL' and instr.argval == '__class__': has_classcell = True closure = closure or () i = len(closure) # if len(closure) >= 256, # the LOAD_DEREF opcode will use EXTENDED_ARG if i > 255: repl = b'\x90\x01\x88' + i.to_bytes(3, 'little') else: repl = b'\x88' + i.to_bytes(1, 'little') x = instr.offset bytecode[x:x + 2] = repl co_code = bytes(bytecode) # only add a class cell if necessary if has_classcell: cell = build_class_cell(cls) closure = closure or () # insert/replace the __class__ cell if it is already in freevars if '__class__' in co_freevars: i = co_freevars.index('__class__') j = len(closure) == len(co_freevars) closure = (*closure[:i], cell, *closure[i + j:]) # add if it doesn't else: co_freevars += ('__class__', ) closure += (cell, ) # ensure NOFREE flag is set if there are no frevars if not co_freevars: co_flags = (co_flags | NOFREE) if f.__closure__ is not None: raise TypeError('function closure was a tuple when its' 'code.co_freevars was empty') # since python 3.6, the NOFREE flag actually does what it's # supposed to do, so it must be unset to enable access of __closure__ else: co_flags = (co_flags | NOFREE) ^ NOFREE code = update_code(code, freevars=co_freevars, flags=co_flags, names=co_names, code=co_code) method = FunctionType(code, global_ns, closure=closure) method.__defaults__ = defaults method.__kwdefaults__ = kwdefaults method.__name__ = name method.__qualname__ = qualname method.__annotations__ = annotations method.__module__ = module method.__doc__ = doc FunctionType.__dict__['__dict__'].__set__(method, new_dict) for wrapper in reversed(wrappers): method = wrapper(method) return method