我们从Python开源项目中，提取了以下26个代码示例，用于说明如何使用inspect.getclosurevars()。
def _make_command_requirements(command): requirements = [] # All commands in this cog are owner-only anyway. if command.cog_name == 'Owner': requirements.append('**Bot Owner only**') def make_pretty(p): return p.replace('_', ' ').title().replace('Guild', 'Server') for check in command.checks: name = getattr(check, '__qualname__', '') if name.startswith('is_owner'): # the bot owner line must come above every other line, for emphasis. requirements.insert(0, '**Bot Owner only**') elif name.startswith('has_permissions'): permissions = inspect.getclosurevars(check).nonlocals['perms'] pretty_perms = [make_pretty(k) if v else f'~~{make_pretty(k)}~~' for k, v in permissions.items()] perm_names = ', '.join(pretty_perms) requirements.append(f'{perm_names} permission{"s" * (len(pretty_perms) != 1)}') return '\n'.join(requirements)
def test_name_resolution(self): # Basic test of the 4 different resolution mechanisms def f(nonlocal_ref): def g(local_ref): print(local_ref, nonlocal_ref, _global_ref, unbound_ref) return g _arg = object() nonlocal_vars = {"nonlocal_ref": _arg} global_vars = {"_global_ref": _global_ref} builtin_vars = {"print": print} unbound_names = {"unbound_ref"} expected = inspect.ClosureVars(nonlocal_vars, global_vars, builtin_vars, unbound_names) self.assertEqual(inspect.getclosurevars(f(_arg)), expected)
def test_generator_closure(self): def f(nonlocal_ref): def g(local_ref): print(local_ref, nonlocal_ref, _global_ref, unbound_ref) yield return g _arg = object() nonlocal_vars = {"nonlocal_ref": _arg} global_vars = {"_global_ref": _global_ref} builtin_vars = {"print": print} unbound_names = {"unbound_ref"} expected = inspect.ClosureVars(nonlocal_vars, global_vars, builtin_vars, unbound_names) self.assertEqual(inspect.getclosurevars(f(_arg)), expected)
def test_method_closure(self): class C: def f(self, nonlocal_ref): def g(local_ref): print(local_ref, nonlocal_ref, _global_ref, unbound_ref) return g _arg = object() nonlocal_vars = {"nonlocal_ref": _arg} global_vars = {"_global_ref": _global_ref} builtin_vars = {"print": print} unbound_names = {"unbound_ref"} expected = inspect.ClosureVars(nonlocal_vars, global_vars, builtin_vars, unbound_names) self.assertEqual(inspect.getclosurevars(C().f(_arg)), expected)
def test_nonlocal_vars(self): # More complex tests of nonlocal resolution def _nonlocal_vars(f): return inspect.getclosurevars(f).nonlocals def make_adder(x): def add(y): return x + y return add def curry(func, arg1): return lambda arg2: func(arg1, arg2) def less_than(a, b): return a < b # The infamous Y combinator. def Y(le): def g(f): return le(lambda x: f(f)(x)) Y.g_ref = g return g(g) def check_y_combinator(func): self.assertEqual(_nonlocal_vars(func), {'f': Y.g_ref}) inc = make_adder(1) add_two = make_adder(2) greater_than_five = curry(less_than, 5) self.assertEqual(_nonlocal_vars(inc), {'x': 1}) self.assertEqual(_nonlocal_vars(add_two), {'x': 2}) self.assertEqual(_nonlocal_vars(greater_than_five), {'arg1': 5, 'func': less_than}) self.assertEqual(_nonlocal_vars((lambda x: lambda y: x + y)(3)), {'x': 3}) Y(check_y_combinator)
def test_getclosurevars_empty(self): def foo(): pass _empty = inspect.ClosureVars({}, {}, {}, set()) self.assertEqual(inspect.getclosurevars(lambda: True), _empty) self.assertEqual(inspect.getclosurevars(foo), _empty)
def test_builtins_fallback(self): f, ns = self._private_globals() ns.pop("__builtins__", None) expected = inspect.ClosureVars({}, {}, {"print":print}, {"path"}) self.assertEqual(inspect.getclosurevars(f), expected)
def test_builtins_as_dict(self): f, ns = self._private_globals() ns["__builtins__"] = {"path":1} expected = inspect.ClosureVars({}, {}, {"path":1}, {"print"}) self.assertEqual(inspect.getclosurevars(f), expected)
def test_builtins_as_module(self): f, ns = self._private_globals() ns["__builtins__"] = os expected = inspect.ClosureVars({}, {}, {"path":os.path}, {"print"}) self.assertEqual(inspect.getclosurevars(f), expected)
def _hash_filter_fn(self, filter_fn, **kwargs): """ Construct string representing state of filter_fn Used to cache filtered variants or effects uniquely depending on filter fn values """ filter_fn_name = self._get_function_name(filter_fn, default="filter-none") logger.debug("Computing hash for filter_fn: {} with kwargs {}".format(filter_fn_name, str(dict(**kwargs)))) # hash function source code fn_source = str(dill.source.getsource(filter_fn)) pickled_fn_source = pickle.dumps(fn_source) ## encode as byte string hashed_fn_source = int(hashlib.sha1(pickled_fn_source).hexdigest(), 16) % (10 ** 11) # hash kwarg values kw_dict = dict(**kwargs) kw_hash = list() if not kw_dict: kw_hash = ["default"] else: [kw_hash.append("{}-{}".format(key, h)) for (key, h) in sorted(kw_dict.items())] # hash closure vars - for case where filter_fn is defined within closure of filter_fn closure = [] nonlocals = inspect.getclosurevars(filter_fn).nonlocals for (key, val) in nonlocals.items(): ## capture hash for any function within closure if inspect.isfunction(val): closure.append(self._hash_filter_fn(val)) closure.sort() # Sorted for file name consistency closure_str = "null" if len(closure) == 0 else "-".join(closure) # construct final string comprising hashed components hashed_fn = ".".join(["-".join([filter_fn_name, str(hashed_fn_source)]), ".".join(kw_hash), closure_str] ) return hashed_fn
