class ConstructorMutableAttribsLineNumberFixture: definition_is_none = None definition_is_not_a_function = _ast.Pass constructor_with_empty_body = _ast.FunctionDef(name='__init__', body=[]) try: constructor_with_immutable = _ast.FunctionDef( name='__init__', body=[ _ast.Assign(lineno=1, value=_ast.Tuple(elts=[1, 2, 3])), _ast.Assign(lineno=2, value=_ast.Str(s='a')), ], ) except (AttributeError): constructor_with_immutable = _ast.FunctionDef( name='__init__', body=[ _ast.Assign(lineno=1, value=_ast.Tuple(elts=[1, 2, 3])), _ast.Assign(lineno=3, value=_ast.JoinedStr(values=None)), ], ) constructor_with_mutable = _ast.FunctionDef( name='__init__', body=[ _ast.Assign(lineno=1, value=_ast.List(elts=[1, 2, 3])), _ast.Assign(lineno=2, value=_ast.Set(elts=[1, 2, 3])), _ast.Assign(lineno=3, value=_ast.Dict(keys=['a'])), ], )
class SetterOrGetterDefNamesLineNumbersFixture: definition_is_none = None definition_is_pass = _ast.Pass() name_is_none = _ast.FunctionDef(name=None) without_setget_keywords = _ast.FunctionDef(name='test') with_set_keywords = _ast.FunctionDef(name='set_test', lineno=1) with_get_keywords = _ast.FunctionDef(name='get_test', lineno=2)
class ReflectionAtLineFixture: empty_node = _ast.Pass is_instance_at_first_lvl = _ast.FunctionDef(id='isinstance', lineno=1) type_at_first_lvl = _ast.FunctionDef(id='type', lineno=1) is_instance_at_second_lvl = _ast.FunctionDef( body=[_ast.Expr(id='isinstance', lineno=2)], lineno=1) type_at_second_lvl = _ast.FunctionDef( body=[_ast.Expr(id='type', lineno=2)], lineno=1)
class NonAssertMethodAtTestFunctionFixture: definition_is_none = None definitions_is_not_a_function = _ast.Pass() definitions_is_not_a_test_function = _ast.FunctionDef(name='not_a_test') definitions_with_only_assert = _ast.FunctionDef(name='test', body=[_ast.Assert()]) definitions_with_code = _ast.FunctionDef( name='test', body=[_ast.Pass(lineno=1), _ast.Assert()])
class ConstructorNonAttribsValueLineNumberFixture: definition_is_none = None definition__is_not_a_function = _ast.Pass definitions_is_not_a_constructor = _ast.FunctionDef(name='test', body=[_ast.Expr(lineno=1)]) definitions_consist_of_assign_with_attribute = _ast.FunctionDef( name='__init__', body=[_ast.Assign(targets=[_ast.Attribute(lineno=2)], lineno=1)], ) definitions_consist_of_assign_without_attribute = _ast.FunctionDef( name='__init__', body=[_ast.Assign(targets=[_ast.Expr(lineno=2)], lineno=1)], ) definitions_consist_of_any_but_not_a_assign = _ast.FunctionDef(name='__init__', body=[_ast.Pass(lineno=3)])
def FunctionDef(name, args=(), keys=(), values=(), body=None, vararg_name=None, kwarg_name=None, decorator_list=()): """Creates an _ast.FunctionDef node. Args: name: The name of the function. args: A list of args. keys: A list of keys, must be the same length as values. values: A list of values, correspond to keys. body: A list of _ast.stmt nodes that go in the body of the function. vararg_name: The name of the vararg variable, or None. kwarg_name: The name of the kwargs variable, or None. decorator_list: A list of decorator nodes. Raises: ValueError: If len(keys) != len(values). Returns: An _ast.FunctionDef node. """ body = FormatAndValidateBody(body) args = arguments(args=args, keys=keys, values=values, vararg_name=vararg_name, kwarg_name=kwarg_name) return _ast.FunctionDef(name=name, args=args, body=body, decorator_list=list(decorator_list))
def test_missing_name(self): import _ast as ast n = ast.FunctionDef(name=None) n.name = "foo" n.name = "foo" n.name = "foo" assert n.name == "foo"
class SetEncapsulatedAttribsLineNumbersFixture: definition_is_none = None definition_is_pass = _ast.Pass() is_constructor = _ast.FunctionDef(name='__init__') without_assign = _ast.FunctionDef(name='test', body=[_ast.Pass()]) with_assign_without_self = _ast.FunctionDef( name='test', body=[ _ast.Pass(), _ast.Assign(targets=[_ast.Attribute(value=(_ast.Name(id='test')), lineno=1)]), ], ) with_assign_with_self = _ast.FunctionDef( name='test', body=[ _ast.Pass(), _ast.Assign(targets=[_ast.Attribute(value=(_ast.Name(id='self')), lineno=1)]), ], )
def function_def_stmt(name: str, args: _ast.arguments, body: List[_ast.stmt], decorator_list: List[_ast.expr]) -> _ast.FunctionDef: return _ast.FunctionDef(name=name, args=args, body=body, decorator_list=decorator_list, returns=None, type_comment=None)
class ConstructorFixture: constructor_without_params = _ast.ClassDef( name='Test', body=[ _ast.FunctionDef( name='__init__', body=[_ast.Pass()], ), ], bases=None, ) empty_class = _ast.ClassDef( name='Test', body=[], bases=None, ) class_without_constructor = _ast.ClassDef( name='Test', body=[ _ast.FunctionDef( name='some_function', body=[_ast.Pass()], ), ], bases=None, ) class_with_constructor_and_additional_method = _ast.ClassDef( name='Test', body=[ _ast.FunctionDef( name='some_function', body=[_ast.Pass()], ), _ast.FunctionDef( name='__init__', body=[_ast.Pass()], ), ], bases=None, ) class_with_inheritance = _ast.ClassDef( name='Test', body=[], bases=[_ast.ClassDef(name='TestParent')], )
class ReturnedValueFixture: node_is_none = None assign_expression_as_input = _ast.Assign(lineno=1) pass_expression_as_input = _ast.Pass(lineno=1) plain_expression_as_input = _ast.Expr(lineno=1) function_body_is_empty = _ast.FunctionDef(lineno=1, body=[]) function_body_without_return_expression = _ast.FunctionDef( lineno=1, body=[_ast.Pass(), _ast.Expr(), _ast.Assign], ) function_body_with_return_expression = _ast.FunctionDef( lineno=1, body=[ _ast.Pass(), _ast.Expr(), _ast.Assign(), _ast.Return(lineno=1, value=None) ], )
def _replace_where_block_with_function(self, with_node): return _ast.FunctionDef(name=self.feature_name + '_where', args=_ast.arguments( args=[_ast.arg(arg='self'), _ast.arg(arg='injectable_values')], kwonlyargs=[], kw_defaults=[], defaults=[] ), body=copy.deepcopy(with_node.body), decorator_list=[], returns=None)
def make_function(code, defaults=None, lineno=0): from meta.decompiler.disassemble import disassemble instructions = Instructions(disassemble(code)) stmnts = instructions.stmnt() if code.co_flags & 2: vararg = None kwarg = None varnames = list(code.co_varnames[:code.co_argcount]) co_locals = list(code.co_varnames[code.co_argcount:]) #have var args if code.co_flags & 4: vararg = co_locals.pop(0) #have kw args if code.co_flags & 8: kwarg = co_locals.pop() args = [_ast.Name(id=argname, ctx=_ast.Param(), lineno=lineno, col_offset=0) for argname in varnames] args = _ast.arguments(args=args, defaults=defaults if defaults else [], kwarg=kwarg, vararg=vararg, lineno=lineno, col_offset=0 ) if code.co_name == '<lambda>': if len(stmnts) == 2: if isinstance(stmnts[0], _ast.If) and isinstance(stmnts[1], _ast.Return): assert len(stmnts[0].body) == 1 assert isinstance(stmnts[0].body[0], _ast.Return) stmnts = [_ast.Return(_ast.IfExp(stmnts[0].test, stmnts[0].body[0].value, stmnts[1].value))] assert len(stmnts) == 1, stmnts assert isinstance(stmnts[0], _ast.Return) stmnt = stmnts[0].value ast_obj = _ast.Lambda(args=args, body=stmnt, lineno=lineno, col_offset=0) else: if instructions.seen_yield: return_ = stmnts[-1] assert isinstance(return_, _ast.Return) assert isinstance(return_.value, _ast.Name) assert return_.value.id == 'None' return_.value = None ast_obj = _ast.FunctionDef(name=code.co_name, args=args, body=stmnts, decorator_list=[], lineno=lineno, col_offset=0) return ast_obj
class StaticOrPrivateFixture: definition_is_assign = _ast.Assign() definition_is_pass = _ast.Pass() definition_is_expr = _ast.Expr() empty_decorator_list_and_name = _ast.FunctionDef() empty_decorator_list = _ast.FunctionDef(name='test') is_private = _ast.FunctionDef(name='_test') is_protected = _ast.FunctionDef(name='__test') is_magic = _ast.FunctionDef(name='__test__') decorated = _ast.FunctionDef(name='test', decorator_list=['any_decorator']) is_static = _ast.FunctionDef( name='test', decorator_list=[_ast.FunctionDef(id='staticmethod')], )
def function(self, items): if len(items) == 2: (name, body) = items args = [] else: (name, args, body) = items return _ast.FunctionDef(name=name, args=_ast.arguments(args=args, defaults=[], vararg=None, kwarg=None), body=body, decorator_list=[])
def constructor_method(self, items): (args, body) = items method_args = [_ast.arg(arg='self', annotation=None)] method_args.extend(args) return _ast.FunctionDef(name='__init__', args=_ast.arguments(args=method_args, defaults=[], vararg=None, kwarg=None), body=body, decorator_list=[])
def build_function(): config = menu('name') name = config['name'] function = _ast.FunctionDef(name=name, args=[], defaults=[], body=[], decorator_list=[]) add_ast_node(function) parent = globals['node'] for child in parent.children: if (child.node == function): globals['node'] = child break
def visit_Lambda(self, node): """Rewrite the Lambda visitor function to transform the lambda into a real iterator function. """ iden = self._gen_iden(node) funcnode = _ast.FunctionDef(name=iden, args=node.args, body=[_ast.Return(value=node.body)], decorator_list=[]) self.visit(funcnode) return iden
def test_functiondef(self): import _ast as ast fAst = ast.FunctionDef( name="foo", args=ast.arguments( args=[], vararg=None, kwarg=None, defaults=[], kwonlyargs=[], kw_defaults=[]), body=[], decorator_list=[], lineno=5, col_offset=0) exprAst = ast.Interactive(body=[fAst]) compiled = compile(exprAst, "<foo>", "single") # d = {} eval(compiled, d, d) assert type(d['foo']) is type(lambda: 42) assert d['foo']() is None
def visit_GeneratorExp(self, node): """Rewrite the GeneratorExp visitor function to turn the generator expression into a iterator function. This is necessary to be able to correctly label any random functions that get called from within the generator expression. Basically, this function creates a function, and transforms the generator into a for loop that yields values from the. The function name is then returned, so that the parent node can handle the assignment properly. """ # make an identifier for the list self.newline(node) iden = self._gen_iden(node) argids = [] for gen in node.generators: argval = gen.iter argid = self._gen_iden(gen.iter) self.visit( _ast.Assign(targets=[_ast.Name(id=argid, ctx=_ast.Store())], value=argval)) argids.append(argid) elt = node.elt def parse_generator(nodes, ids): node = nodes[0] tempnode = _ast.For() tempnode.target = node.target tempnode.iter = _ast.Name(id=ids[0], ctx=_ast.Load()) if len(nodes) == 1: yield_node = _ast.Expr(value=_ast.Yield(value=elt)) body = [yield_node] else: body = [parse_generator(nodes[1:], ids[1:])] if len(node.ifs) == 1: ifnode = _ast.If(test=node.ifs[0], body=body, orelse=[]) tempnode.body = [ifnode] elif len(node.ifs) > 1: ifnode = _ast.If(test=_ast.BoolOp(op=_ast.And(), values=node.ifs), body=body, orelse=[]) tempnode.body = [ifnode] else: tempnode.body = body tempnode.orelse = None return tempnode node = _ast.FunctionDef( name=iden, args=_ast.arguments(args=[], vararg=None, kwarg=None, defaults=[]), body=[parse_generator(node.generators, argids)], decorator_list=[]) self.visit(node) return iden
def make_function(code, defaults=None, annotations=(), kw_defaults=(), lineno=0): from ..decompiler.disassemble import disassemble instructions = Instructions(disassemble(code)) stmnts = instructions.stmnt() if code.co_flags & 2: vararg = None kwarg = None varnames = list(code.co_varnames[:code.co_argcount]) kwonly_varnames = list(code.co_varnames[code.co_argcount:code.co_argcount + code.co_kwonlyargcount]) co_locals = list(code.co_varnames[code.co_argcount + code.co_kwonlyargcount:]) assert (len(kw_defaults) % 2) == 0 kw_defaults = list(kw_defaults) kw_default_dict = {} while kw_defaults: name = kw_defaults.pop(0) value = kw_defaults.pop(0) kw_default_dict[name.s] = value kw_defaults = [] for argname in kwonly_varnames: kw_defaults.append(kw_default_dict.pop(argname)) #have var args if code.co_flags & 4: vararg = co_locals.pop(0) #have kw args if code.co_flags & 8: kwarg = co_locals.pop() args = [] annotation_names = [annotation.arg for annotation in annotations] for argname in varnames: if argname in annotation_names: arg = [ annotation for annotation in annotations if annotation.arg == argname ][0] else: arg = _ast.arg(annotation=None, arg=argname, lineno=lineno, col_offset=0) #@UndefinedVariable args.append(arg) kwonlyargs = [] for argname in kwonly_varnames: if argname in annotation_names: arg = [ annotation for annotation in annotations if annotation.arg == argname ][0] else: arg = _ast.arg(annotation=None, arg=argname, lineno=lineno, col_offset=0) #@UndefinedVariable kwonlyargs.append(arg) if 'return' in annotation_names: arg = [ annotation for annotation in annotations if annotation.arg == 'return' ][0] returns = arg.annotation else: returns = None if vararg in annotation_names: arg = [ annotation for annotation in annotations if annotation.arg == vararg ][0] varargannotation = arg.annotation else: varargannotation = None if kwarg in annotation_names: arg = [ annotation for annotation in annotations if annotation.arg == kwarg ][0] kwargannotation = arg.annotation else: kwargannotation = None args = _ast.arguments(args=args, defaults=defaults if defaults else [], kwarg=kwarg, vararg=vararg, kw_defaults=kw_defaults, kwonlyargs=kwonlyargs, kwargannotation=kwargannotation, varargannotation=varargannotation, lineno=lineno, col_offset=0) if code.co_name == '<lambda>': if len(stmnts) == 2: if isinstance(stmnts[0], _ast.If) and isinstance( stmnts[1], _ast.Return): assert len(stmnts[0].body) == 1 assert isinstance(stmnts[0].body[0], _ast.Return) stmnts = [ _ast.Return( _ast.IfExp(stmnts[0].test, stmnts[0].body[0].value, stmnts[1].value)) ] assert isinstance(stmnts[0], _ast.Return) stmnt = stmnts[0].value ast_obj = _ast.Lambda(args=args, body=stmnt, lineno=lineno, col_offset=0) else: if instructions.seen_yield: return_ = stmnts[-1] assert isinstance(return_, _ast.Return) assert isinstance(return_.value, _ast.Name) assert return_.value.id == 'None' return_.value = None ast_obj = _ast.FunctionDef(name=code.co_name, args=args, body=stmnts, decorator_list=[], returns=returns, lineno=lineno, col_offset=0) return ast_obj
def _replace_where_block_with_function(self, with_node): return _ast.FunctionDef(name=self.feature_name + '_where', args=ast_proxy.ast_args([_ast.arg(arg='self'), _ast.arg(arg='injectable_values')]), body=copy.deepcopy(with_node.body), decorator_list=[], returns=None)