def test_arguments(self):
x = ast.arguments()
self.assertEqual(x._fields, ('args', 'vararg', 'kwarg', 'defaults'))
with self.assertRaises(AttributeError):
x.vararg
x = ast.arguments(1, 2, 3, 4)
self.assertEqual(x.vararg, 2)
python类arguments()的实例源码
def test_arguments(self):
x = ast.arguments()
self.assertEqual(x._fields, ('args', 'vararg', 'kwarg', 'defaults'))
with self.assertRaises(AttributeError):
x.vararg
x = ast.arguments(1, 2, 3, 4)
self.assertEqual(x.vararg, 2)
def test_AST_objects(self):
x = ast.AST()
self.assertEqual(x._fields, ())
x.foobar = 42
self.assertEqual(x.foobar, 42)
self.assertEqual(x.__dict__["foobar"], 42)
with self.assertRaises(AttributeError):
x.vararg
with self.assertRaises(TypeError):
# "_ast.AST constructor takes 0 positional arguments"
ast.AST(2)
def test_arguments(self):
x = ast.arguments()
self.assertEqual(x._fields, ('args', 'vararg', 'varargannotation',
'kwonlyargs', 'kwarg', 'kwargannotation',
'defaults', 'kw_defaults'))
with self.assertRaises(AttributeError):
x.vararg
x = ast.arguments(*range(1, 9))
self.assertEqual(x.vararg, 2)
def _check_arguments(self, fac, check):
def arguments(args=None, vararg=None, varargannotation=None,
kwonlyargs=None, kwarg=None, kwargannotation=None,
defaults=None, kw_defaults=None):
if args is None:
args = []
if kwonlyargs is None:
kwonlyargs = []
if defaults is None:
defaults = []
if kw_defaults is None:
kw_defaults = []
args = ast.arguments(args, vararg, varargannotation, kwonlyargs,
kwarg, kwargannotation, defaults, kw_defaults)
return fac(args)
args = [ast.arg("x", ast.Name("x", ast.Store()))]
check(arguments(args=args), "must have Load context")
check(arguments(varargannotation=ast.Num(3)),
"varargannotation but no vararg")
check(arguments(varargannotation=ast.Name("x", ast.Store()), vararg="x"),
"must have Load context")
check(arguments(kwonlyargs=args), "must have Load context")
check(arguments(kwargannotation=ast.Num(42)),
"kwargannotation but no kwarg")
check(arguments(kwargannotation=ast.Name("x", ast.Store()),
kwarg="x"), "must have Load context")
check(arguments(defaults=[ast.Num(3)]),
"more positional defaults than args")
check(arguments(kw_defaults=[ast.Num(4)]),
"length of kwonlyargs is not the same as kw_defaults")
args = [ast.arg("x", ast.Name("x", ast.Load()))]
check(arguments(args=args, defaults=[ast.Name("x", ast.Store())]),
"must have Load context")
args = [ast.arg("a", ast.Name("x", ast.Load())),
ast.arg("b", ast.Name("y", ast.Load()))]
check(arguments(kwonlyargs=args,
kw_defaults=[None, ast.Name("x", ast.Store())]),
"must have Load context")
def test_funcdef(self):
a = ast.arguments([], None, None, [], None, None, [], [])
f = ast.FunctionDef("x", a, [], [], None)
self.stmt(f, "empty body on FunctionDef")
f = ast.FunctionDef("x", a, [ast.Pass()], [ast.Name("x", ast.Store())],
None)
self.stmt(f, "must have Load context")
f = ast.FunctionDef("x", a, [ast.Pass()], [],
ast.Name("x", ast.Store()))
self.stmt(f, "must have Load context")
def fac(args):
return ast.FunctionDef("x", args, [ast.Pass()], [], None)
self._check_arguments(fac, self.stmt)
def _make_list_func(tree, field_names_dict, filename=None, add_args=None):
filename = filename or '<generated>'
list_name = 'data'
rewriter = RewriteName(list_name, field_names_dict)
lambda_args = [ast.Name(id=list_name, ctx=ast.Param(), lineno=0, col_offset=0)]
for arg in (add_args or []):
lambda_args.append(
ast.Name(id=arg, ctx=ast.Param(), lineno=0, col_offset=0)
)
tree = rewriter.visit(tree)
tree = ast.Expression(
body = ast.Lambda(
lineno = 0,
col_offset = 0,
body = tree.body,
args = ast.arguments(
args = lambda_args,
vararg = None,
kwarg = None,
defaults = [],
)
),
)
code = compile(tree, filename, 'eval')
func = eval(code)
return func
def visit(self, node):
'''Return the formatted version of an Ast node, or list of Ast nodes.'''
if isinstance(node, (list, tuple)):
return ','.join([self.visit(z) for z in node])
elif node is None:
return 'None'
else:
assert isinstance(node, ast.AST), node.__class__.__name__
method_name = 'do_' + node.__class__.__name__
method = getattr(self, method_name)
s = method(node)
# assert type(s) == type('abc'), (node, type(s))
assert g.isString(s), type(s)
return s
# Contexts...
# 2: ClassDef(identifier name, expr* bases,
# stmt* body, expr* decorator_list)
# 3: ClassDef(identifier name, expr* bases,
# keyword* keywords, expr? starargs, expr? kwargs
# stmt* body, expr* decorator_list)
#
# keyword arguments supplied to call (NULL identifier for **kwargs)
# keyword = (identifier? arg, expr value)
def do_Store(self, node):
return 'Store'
# Operands...
# 2: arguments = (expr* args, identifier? vararg, identifier? kwarg, expr* defaults)
# 3: arguments = (arg* args, arg? vararg,
# arg* kwonlyargs, expr* kw_defaults,
# arg? kwarg, expr* defaults)
def do_arguments(self, node):
'''Format the arguments node.'''
kind = self.kind(node)
assert kind == 'arguments', kind
args = [self.visit(z) for z in node.args]
defaults = [self.visit(z) for z in node.defaults]
# Assign default values to the last args.
args2 = []
n_plain = len(args) - len(defaults)
for i in range(len(args)):
if i < n_plain:
args2.append(args[i])
else:
args2.append('%s=%s' % (args[i], defaults[i - n_plain]))
if isPython3:
args = [self.visit(z) for z in node.kwonlyargs]
defaults = [self.visit(z) for z in node.kw_defaults]
n_plain = len(args) - len(defaults)
for i in range(len(args)):
if i < n_plain:
args2.append(args[i])
else:
args2.append('%s=%s' % (args[i], defaults[i - n_plain]))
# Add the vararg and kwarg expressions.
vararg = getattr(node, 'vararg', None)
if vararg: args2.append('*' + self.visit(vararg))
kwarg = getattr(node, 'kwarg', None)
if kwarg: args2.append('**' + self.visit(kwarg))
else:
# Add the vararg and kwarg names.
name = getattr(node, 'vararg', None)
if name: args2.append('*' + name)
name = getattr(node, 'kwarg', None)
if name: args2.append('**' + name)
return ','.join(args2)
# 3: arg = (identifier arg, expr? annotation)
def __init__ (self):
'''Ctor for StandAloneMakeStubFile class.'''
self.options = {}
# Ivars set on the command line...
self.config_fn = None
# self.finalize('~/stubs/make_stub_files.cfg')
self.enable_unit_tests = False
self.files = [] # May also be set in the config file.
# Ivars set in the config file...
self.output_fn = None
self.output_directory = self.finalize('.')
# self.finalize('~/stubs')
self.overwrite = False
self.prefix_lines = []
self.trace_matches = False
self.trace_patterns = False
self.trace_reduce = False
self.trace_visitors = False
self.update_flag = False
self.verbose = False # Trace config arguments.
self.warn = False
# Pattern lists, set by config sections...
self.section_names = (
'Global', 'Def Name Patterns', 'General Patterns')
self.def_patterns = [] # [Def Name Patterns]
self.general_patterns = [] # [General Patterns]
self.names_dict = {}
self.op_name_dict = self.make_op_name_dict()
self.patterns_dict = {}
self.regex_patterns = []
def do_Compare(self, node):
'''
StubFormatter ast.Compare visitor for these ops:
'==', '!=', '<', '<=', '>', '>=', 'is', 'is not', 'in', 'not in',
'''
s = 'bool' # Correct regardless of arguments.
ops = ','.join([self.op_name(z) for z in node.ops])
self.trace_visitor(node, ops, s)
return s
# If(expr test, stmt* body, stmt* orelse)
def visit_ClassDef(self, node):
# Create the stub in the old context.
old_stub = self.parent_stub
self.parent_stub = Stub('class', node.name,old_stub, self.context_stack)
self.add_stub(self.stubs_dict, self.parent_stub)
# Enter the new context.
self.class_name_stack.append(node.name)
self.context_stack.append(node.name)
if self.trace_matches or self.trace_reduce:
print('\nclass %s\n' % node.name)
# Format...
bases = [self.visit(z) for z in node.bases] if node.bases else []
if getattr(node, 'keywords', None): # Python 3
for keyword in node.keywords:
bases.append('%s=%s' % (keyword.arg, self.visit(keyword.value)))
if getattr(node, 'starargs', None): # Python 3
bases.append('*%s', self.visit(node.starargs))
if getattr(node, 'kwargs', None): # Python 3
bases.append('*%s', self.visit(node.kwargs))
if not node.name.startswith('_'):
if node.bases:
s = '(%s)' % ', '.join([self.format(z) for z in node.bases])
else:
s = ''
self.out('class %s%s:' % (node.name, s))
# Visit...
self.level += 1
for z in node.body:
self.visit(z)
self.context_stack.pop()
self.class_name_stack.pop()
self.level -= 1
self.parent_stub = old_stub
# 2: FunctionDef(identifier name, arguments args, stmt* body, expr* decorator_list)
# 3: FunctionDef(identifier name, arguments args, stmt* body, expr* decorator_list,
# expr? returns)
def format_arguments(self, node):
'''
Format the arguments node.
Similar to AstFormat.do_arguments, but it is not a visitor!
'''
assert isinstance(node,ast.arguments), node
args = [self.raw_format(z) for z in node.args]
defaults = [self.raw_format(z) for z in node.defaults]
# Assign default values to the last args.
result = []
n_plain = len(args) - len(defaults)
# pylint: disable=consider-using-enumerate
for i in range(len(args)):
s = self.munge_arg(args[i])
if i < n_plain:
result.append(s)
else:
result.append('%s=%s' % (s, defaults[i - n_plain]))
# Now add the vararg and kwarg args.
name = getattr(node, 'vararg', None)
if name:
if hasattr(ast, 'arg'): # python 3:
name = self.raw_format(name)
result.append('*' + name)
name = getattr(node, 'kwarg', None)
if name:
if hasattr(ast, 'arg'): # python 3:
name = self.raw_format(name)
result.append('**' + name)
return ', '.join(result)
def make_args_list(args):
return ast.arguments(args=args, vararg=None, kwarg=None, defaults=[])
def test_arguments(self):
x = ast.arguments()
self.assertEqual(x._fields, ('args', 'vararg', 'kwarg', 'defaults'))
with self.assertRaises(AttributeError):
x.vararg
x = ast.arguments(1, 2, 3, 4)
self.assertEqual(x.vararg, 2)
def test_AST_objects(self):
x = ast.AST()
self.assertEqual(x._fields, ())
x.foobar = 42
self.assertEqual(x.foobar, 42)
self.assertEqual(x.__dict__["foobar"], 42)
with self.assertRaises(AttributeError):
x.vararg
with self.assertRaises(TypeError):
# "_ast.AST constructor takes 0 positional arguments"
ast.AST(2)
def test_arguments(self):
x = ast.arguments()
self.assertEqual(x._fields, ('args', 'vararg', 'kwonlyargs',
'kw_defaults', 'kwarg', 'defaults'))
with self.assertRaises(AttributeError):
x.vararg
x = ast.arguments(*range(1, 7))
self.assertEqual(x.vararg, 2)
def _check_arguments(self, fac, check):
def arguments(args=None, vararg=None,
kwonlyargs=None, kwarg=None,
defaults=None, kw_defaults=None):
if args is None:
args = []
if kwonlyargs is None:
kwonlyargs = []
if defaults is None:
defaults = []
if kw_defaults is None:
kw_defaults = []
args = ast.arguments(args, vararg, kwonlyargs, kw_defaults,
kwarg, defaults)
return fac(args)
args = [ast.arg("x", ast.Name("x", ast.Store()))]
check(arguments(args=args), "must have Load context")
check(arguments(kwonlyargs=args), "must have Load context")
check(arguments(defaults=[ast.Num(3)]),
"more positional defaults than args")
check(arguments(kw_defaults=[ast.Num(4)]),
"length of kwonlyargs is not the same as kw_defaults")
args = [ast.arg("x", ast.Name("x", ast.Load()))]
check(arguments(args=args, defaults=[ast.Name("x", ast.Store())]),
"must have Load context")
args = [ast.arg("a", ast.Name("x", ast.Load())),
ast.arg("b", ast.Name("y", ast.Load()))]
check(arguments(kwonlyargs=args,
kw_defaults=[None, ast.Name("x", ast.Store())]),
"must have Load context")
def test_funcdef(self):
a = ast.arguments([], None, [], [], None, [])
f = ast.FunctionDef("x", a, [], [], None)
self.stmt(f, "empty body on FunctionDef")
f = ast.FunctionDef("x", a, [ast.Pass()], [ast.Name("x", ast.Store())],
None)
self.stmt(f, "must have Load context")
f = ast.FunctionDef("x", a, [ast.Pass()], [],
ast.Name("x", ast.Store()))
self.stmt(f, "must have Load context")
def fac(args):
return ast.FunctionDef("x", args, [ast.Pass()], [], None)
self._check_arguments(fac, self.stmt)
