def atom_expr_rewrite(a: t.Optional[Tokenizer], atom: ast.AST, trailers: t.List[t.Callable[[ast.AST], ast.Suite]]): for each in trailers: atom = each(atom) if a: atom = ast.Await(**(loc @ a), value=atom) return atom
def r_await(node: ast.Subscript, ctx: Context, clauses: list): ctx.assert_clause_num_at_most(clauses, 2) await_clause = clauses[0] ctx.assert_no_head(await_clause) ctx.assert_single_body(await_clause) value = ctx.compile(await_clause.unwrap_body()) return copy_lineinfo(node, ast.Await(value=value))
def p_call_expr(p): '''expression : expression tuple''' #| PURE expression tuple''' if len(p) == 3: runner = ast.Name("_hio_interpret_call", ast.Load()) args = list(p[2]) args.insert(0, p[1]) call = ast.Call(runner, args, []) p[0] = ast.Await(call) else: p[0] = ast.Call(p[2], list(p[3]), [])
def p_atom_expr4(self, p): ''' atom_expr : AWAIT atom trailer_list ''' root = p[2] for node in p[3]: if isinstance(node, ast.Call): node.func = root elif isinstance(node, ast.Attribute): node.value = root elif isinstance(node, ast.Subscript): node.value = root else: raise TypeError('Unexpected trailer node: %s' % node) root = node p[0] = ast.Await(value=node)
def visit_Call(self, node): if type(node.func) is ast.Name and node.func.id.startswith( '__await__'): if self.params[get_await_param(node.func.id)]: # pragma: no cover if ASYNC_AWAIT: return ast.Await(value=node.args[0], lineno=node.lineno, col_offset=node.col_offset) else: return ast.YieldFrom(value=node.args[0], lineno=node.lineno, col_offset=node.col_offset) else: return node.args[0] return self.generic_visit(node)
def build_ret(method, rtype_arg): tmpl = ( "return self._make_request(self.b.artist(artist_id=artist_id), Artist)" ) ret = ast.parse(tmpl).body[0] ret.value.args[1] = rtype_arg # type: ignore # TODO: Skip first arg (it's self) ret.value.args[0].args = [] # type: ignore ret.value.args[0].keywords = signature_to_keywords(method) # type: ignore ret.value.args[0].func.attr = method.name # type: ignore async_ret = deepcopy(ret) async_ret.value = ast.Await(ret.value) # type: ignore return ret, async_ret
def add_extras(klass: ast.ClassDef): if not klass.name.endswith("Auth"): return assign_methods = [ ( "authorize_user", "get_token_from_code", "token", _doc_authorize_user, ), ( "authorize_client", "get_token_from_client_credentials", "token", _doc_authorize_client, ), ( "refresh_authorization", "get_token_from_refresh_token", "token", _doc_refresh_authorization, ), ] tmpl = 'self._assign_result("token", self.method_name())' for methname, mirroredname, assignto, docstring in assign_methods: mirrored = find_method(klass, mirroredname) meth = deepcopy(mirrored) meth.name = methname keywords = signature_to_keywords(mirrored) assignment = ast.parse(tmpl).body[0] assignment.value.args[0].s = assignto # type: ignore assignment.value.args[1].func.attr = mirrored.name # type: ignore assignment.value.args[1].keywords = keywords # type: ignore if isinstance(meth, ast.AsyncFunctionDef): assignment = ast.Expr(ast.Await(assignment.value)) # type: ignore body = [assignment] if docstring: docobj = ast.Expr(ast.Str(docstring)) body.insert(0, docobj) meth.body = body meth.returns = None klass.body.append(meth)
def visit_YieldFrom(self, node): return ast.Await(node.value)
[ast.ImportFrom("__future__", names=[ast.alias(name="lol")])]), "'lol' is not defined", ), ( ast.Assign(targets=[ast.Starred(), ast.Starred()]), "More then one starred expression", ), ( ast.Assign(targets=([ast.Name("i")] * 500 + [ast.Starred()])), "Too many expressions", ), ( ast.Assign(targets=([ast.Name("i")] * 500 + [ast.Starred()])), "Too many expressions", ), (ast.comprehension(is_async=1), "inside of a coroutine"), (ast.Yield(), "inside of a function"), ( ast.AsyncFunctionDef(body=[ast.YieldFrom()]), "can't be used in a coroutine", ), (ast.Await(), "inside of a function"), (ast.FunctionDef(body=[ast.Await()]), "inside of a coroutine"), ], ) def test_simple_ast_validator(node, message): validator = ContextualASTValidator() with pytest.raises(SyntaxError) as cm: validator.validate(ast.fix_missing_locations(node)) assert cm.match(message)
def visit_Call(self, node): if self.is_magic_call(node): return ast.copy_location(ast.Await(value=node), node) return node
def p_atom_expr3(self, p): ''' atom_expr : AWAIT atom ''' p[0] = ast.Await(value=p[2])
def visit_Await(self, node: Await, *args, **kwargs) -> C.Await: value = self.visit(node.value, *args, **kwargs) return C.Await(value=value, )
def make_await(): """Await(expr value)""" # TODO: Use the selected expression if possible return ast.Await(value=make_expression())
def r_await(node: ast.Attribute, ctx: Context): value = ctx.compile(node.value) return copy_lineinfo(node, ast.Await(value=value))
def generate_await(max_depth=None): return ast.Expr(ast.Await(generate_expression(max_depth=max_depth - 1)))
def Await(draw, expression) -> ast.Await: return ast.Await(draw(expression))
def visit_Call(self, node: ast.Call) -> Union[ast.Call, ast.Await]: if ((not isinstance(node.func, ast.Name) or node.func.id != AWAIT_FUNC_NAME or len(node.args) != 1 or len(node.keywords) != 0)): return node return ast.copy_location(ast.Await(value=node.args[0]), node)