def require(*args, **kwargs): """ Requires the given parameters. Parameters ---------- *args : Parameters Required variable names. **kwargs : Keyword parameters Variables and their expected value / type. """ module_globals = get_frame().f_back.f_globals for variable_name in args: if variable_name not in module_globals: raise DoNotLoadExtension(variable_name) for variable_name, expected_value in kwargs.items(): try: variable_value = module_globals[variable_name] except KeyError: raise DoNotLoadExtension(variable_name) from None if variable_value is expected_value: continue if isinstance(expected_value, type) and isinstance( variable_value, expected_value): continue raise DoNotLoadExtension(variable_name, variable_value, expected_value)
def get_module_frame(module, allow_local=True, start_frame=None, stacklevel=None): ''' Returns the stack frame that *module* is being executed in. If the stack frame can not be found, a `RuntimeError` is raised. ''' if not start_frame and stacklevel is not None: frame = get_frame(stacklevel) elif start_frame: frame = start_frame else: frame = get_frame(1) while frame: if frame.f_globals is vars(module): if frame.f_locals is vars(module) or allow_local: return frame frame = frame.f_back raise RuntimeError('module frame can not be found')
def Namespace(*args, **kwargs): """Return a Namespace from the current scope or the given arguments.""" class NamespaceObject(tuple): __metaclass__ = NamespaceContext __slots__ = () def __new__(klass, __getter): return tuple.__new__(klass, __getter) ns_items = []; populate = ns_items.append if args or kwargs: frame = None for arg in args: kwargs[arg.__name__] = arg for name, obj in kwargs.iteritems(): if isinstance(obj, FunctionType): populate((name, staticmethod(obj))) else: populate((name, obj)) else: frame = get_frame(1) for name, obj in frame.f_locals.iteritems(): if isinstance(obj, FunctionType): if not (name.startswith('_') and not name.startswith('__')): populate((name, staticmethod(obj))) elif name.startswith('__') and name.endswith('__'): populate((name, obj)) del frame, args, kwargs # @/@ what should we do with __doc__ and __name__ ?? return NamespaceObject(ns_items)
def this_function_caller_name(delta=0): return get_frame(2 + delta).f_code.co_name
def is_atty(): return fileobj.isatty() def get_encoding(): return fileobj.encoding def get_mode(): return fileobj.mode def get_name(): return fileobj.name def get_newlines(): return fileobj.newlines return Namespace( __repr__, close, read, readline, seek, tell, is_closed, get_encoding, get_mode, get_name, get_newlines ) return FileReader FileReader = _FileReader() # ------------------------------------------------------------------------------ # self runner # ------------------------------------------------------------------------------ secure_python_builtins() sys.get_frame_locals(get_frame(1))['__builtins__'] = __builtin__.__dict__.copy()
def get_caller(stacklevel=1): ''' Returns the name of the calling function. ''' return get_frame(stacklevel).f_code.co_name