Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.8/site-packages/gast/ast3.py: 38%

1from gast.astn import AstToGAst, GAstToAst 

2import gast 

3import ast 

4import sys 

5 

6 

7class Ast3ToGAst(AstToGAst): 

8 if sys.version_info.minor < 10: 

9 

10 def visit_alias(self, node): 

11 new_node = gast.alias( 

12 self._visit(node.name), 

13 self._visit(node.asname), 

14 ) 

15 new_node.lineno = new_node.col_offset = None 

16 new_node.end_lineno = new_node.end_col_offset = None 

17 return new_node 

18 

19 if sys.version_info.minor < 9: 

20 

21 def visit_ExtSlice(self, node): 

22 new_node = gast.Tuple(self._visit(node.dims), gast.Load()) 

23 return gast.copy_location(new_node, node) 

24 

25 def visit_Index(self, node): 

26 return self._visit(node.value) 

27 

28 def visit_Assign(self, node): 

29 new_node = gast.Assign( 

30 self._visit(node.targets), 

31 self._visit(node.value), 

32 None, # type_comment 

33 ) 

34 

35 gast.copy_location(new_node, node) 

36 new_node.end_lineno = new_node.end_col_offset = None 

37 return new_node 

38 

39 if sys.version_info.minor < 8: 

40 def visit_Module(self, node): 

41 new_node = gast.Module( 

42 self._visit(node.body), 

43 [] # type_ignores 

44 ) 

45 return new_node 

46 

47 def visit_Num(self, node): 

48 new_node = gast.Constant( 

49 node.n, 

50 None, 

51 ) 

52 return gast.copy_location(new_node, node) 

53 

54 def visit_Ellipsis(self, node): 

55 new_node = gast.Constant( 

56 Ellipsis, 

57 None, 

58 ) 

59 gast.copy_location(new_node, node) 

60 new_node.end_lineno = new_node.end_col_offset = None 

61 return new_node 

62 

63 def visit_Str(self, node): 

64 new_node = gast.Constant( 

65 node.s, 

66 None, 

67 ) 

68 return gast.copy_location(new_node, node) 

69 

70 def visit_Bytes(self, node): 

71 new_node = gast.Constant( 

72 node.s, 

73 None, 

74 ) 

75 return gast.copy_location(new_node, node) 

76 

77 def visit_FunctionDef(self, node): 

78 new_node = gast.FunctionDef( 

79 self._visit(node.name), 

80 self._visit(node.args), 

81 self._visit(node.body), 

82 self._visit(node.decorator_list), 

83 self._visit(node.returns), 

84 None, # type_comment 

85 ) 

86 return gast.copy_location(new_node, node) 

87 

88 def visit_AsyncFunctionDef(self, node): 

89 new_node = gast.AsyncFunctionDef( 

90 self._visit(node.name), 

91 self._visit(node.args), 

92 self._visit(node.body), 

93 self._visit(node.decorator_list), 

94 self._visit(node.returns), 

95 None, # type_comment 

96 ) 

97 return gast.copy_location(new_node, node) 

98 

99 def visit_For(self, node): 

100 new_node = gast.For( 

101 self._visit(node.target), 

102 self._visit(node.iter), 

103 self._visit(node.body), 

104 self._visit(node.orelse), 

105 None, # type_comment 

106 ) 

107 return gast.copy_location(new_node, node) 

108 

109 def visit_AsyncFor(self, node): 

110 new_node = gast.AsyncFor( 

111 self._visit(node.target), 

112 self._visit(node.iter), 

113 self._visit(node.body), 

114 self._visit(node.orelse), 

115 None, # type_comment 

116 ) 

117 return gast.copy_location(new_node, node) 

118 

119 def visit_With(self, node): 

120 new_node = gast.With( 

121 self._visit(node.items), 

122 self._visit(node.body), 

123 None, # type_comment 

124 ) 

125 return gast.copy_location(new_node, node) 

126 

127 def visit_AsyncWith(self, node): 

128 new_node = gast.AsyncWith( 

129 self._visit(node.items), 

130 self._visit(node.body), 

131 None, # type_comment 

132 ) 

133 return gast.copy_location(new_node, node) 

134 

135 def visit_Call(self, node): 

136 if sys.version_info.minor < 5: 

137 if node.starargs: 

138 star = gast.Starred(self._visit(node.starargs), 

139 gast.Load()) 

140 gast.copy_location(star, node) 

141 starred = [star] 

142 else: 

143 starred = [] 

144 

145 if node.kwargs: 

146 kw = gast.keyword(None, self._visit(node.kwargs)) 

147 gast.copy_location(kw, node.kwargs) 

148 kwargs = [kw] 

149 else: 

150 kwargs = [] 

151 else: 

152 starred = kwargs = [] 

153 

154 new_node = gast.Call( 

155 self._visit(node.func), 

156 self._visit(node.args) + starred, 

157 self._visit(node.keywords) + kwargs, 

158 ) 

159 return gast.copy_location(new_node, node) 

160 

161 def visit_NameConstant(self, node): 

162 if node.value is None: 

163 new_node = gast.Constant(None, None) 

164 elif node.value is True: 

165 new_node = gast.Constant(True, None) 

166 elif node.value is False: 

167 new_node = gast.Constant(False, None) 

168 return gast.copy_location(new_node, node) 

169 

170 def visit_arguments(self, node): 

171 new_node = gast.arguments( 

172 self._visit(node.args), 

173 [], # posonlyargs 

174 self._visit(node.vararg), 

175 self._visit(node.kwonlyargs), 

176 self._visit(node.kw_defaults), 

177 self._visit(node.kwarg), 

178 self._visit(node.defaults), 

179 ) 

180 return gast.copy_location(new_node, node) 

181 

182 def visit_Name(self, node): 

183 new_node = gast.Name( 

184 node.id, # micro-optimization here, don't call self._visit 

185 self._visit(node.ctx), 

186 None, 

187 None, 

188 ) 

189 return ast.copy_location(new_node, node) 

190 

191 def visit_arg(self, node): 

192 if sys.version_info.minor < 8: 

193 extra_arg = None 

194 else: 

195 extra_arg = self._visit(node.type_comment) 

196 

197 new_node = gast.Name( 

198 node.arg, # micro-optimization here, don't call self._visit 

199 gast.Param(), 

200 self._visit(node.annotation), 

201 extra_arg # type_comment 

202 ) 

203 return ast.copy_location(new_node, node) 

204 

205 def visit_ExceptHandler(self, node): 

206 if node.name: 

207 new_node = gast.ExceptHandler( 

208 self._visit(node.type), 

209 gast.Name(node.name, gast.Store(), None, None), 

210 self._visit(node.body)) 

211 return ast.copy_location(new_node, node) 

212 else: 

213 return self.generic_visit(node) 

214 

215 if sys.version_info.minor < 6: 

216 

217 def visit_comprehension(self, node): 

218 new_node = gast.comprehension( 

219 target=self._visit(node.target), 

220 iter=self._visit(node.iter), 

221 ifs=self._visit(node.ifs), 

222 is_async=0, 

223 ) 

224 return ast.copy_location(new_node, node) 

225 

226 

227class GAstToAst3(GAstToAst): 

228 if sys.version_info.minor < 10: 

229 def visit_alias(self, node): 

230 new_node = ast.alias( 

231 self._visit(node.name), 

232 self._visit(node.asname) 

233 ) 

234 return new_node 

235 

236 if sys.version_info.minor < 9: 

237 def visit_Subscript(self, node): 

238 def adjust_slice(s): 

239 if isinstance(s, ast.Slice): 

240 return s 

241 else: 

242 return ast.Index(s) 

243 if isinstance(node.slice, gast.Tuple): 

244 if any(isinstance(elt, gast.slice) for elt in node.slice.elts): 

245 new_slice = ast.ExtSlice( 

246 [adjust_slice(x) for x in 

247 self._visit(node.slice.elts)]) 

248 else: 

249 value = ast.Tuple(self._visit(node.slice.elts), ast.Load()) 

250 ast.copy_location(value, node.slice) 

251 new_slice = ast.Index(value) 

252 else: 

253 new_slice = adjust_slice(self._visit(node.slice)) 

254 ast.copy_location(new_slice, node.slice) 

255 

256 new_node = ast.Subscript( 

257 self._visit(node.value), 

258 new_slice, 

259 self._visit(node.ctx), 

260 ) 

261 return ast.copy_location(new_node, node) 

262 

263 def visit_Assign(self, node): 

264 new_node = ast.Assign( 

265 self._visit(node.targets), 

266 self._visit(node.value), 

267 ) 

268 

269 return ast.copy_location(new_node, node) 

270 

271 if sys.version_info.minor < 8: 

272 

273 def visit_Module(self, node): 

274 new_node = ast.Module(self._visit(node.body)) 

275 return new_node 

276 

277 def visit_Constant(self, node): 

278 if node.value is None: 

279 new_node = ast.NameConstant(node.value) 

280 elif node.value is Ellipsis: 

281 new_node = ast.Ellipsis() 

282 elif isinstance(node.value, bool): 

283 new_node = ast.NameConstant(node.value) 

284 elif isinstance(node.value, (int, float, complex)): 

285 new_node = ast.Num(node.value) 

286 elif isinstance(node.value, str): 

287 new_node = ast.Str(node.value) 

288 else: 

289 new_node = ast.Bytes(node.value) 

290 return ast.copy_location(new_node, node) 

291 

292 def _make_arg(self, node): 

293 if node is None: 

294 return None 

295 

296 if sys.version_info.minor < 8: 

297 extra_args = tuple() 

298 else: 

299 extra_args = self._visit(node.type_comment), 

300 

301 new_node = ast.arg( 

302 self._visit(node.id), 

303 self._visit(node.annotation), 

304 *extra_args 

305 ) 

306 return ast.copy_location(new_node, node) 

307 

308 def visit_Name(self, node): 

309 new_node = ast.Name( 

310 self._visit(node.id), 

311 self._visit(node.ctx), 

312 ) 

313 return ast.copy_location(new_node, node) 

314 

315 def visit_ExceptHandler(self, node): 

316 if node.name: 

317 new_node = ast.ExceptHandler( 

318 self._visit(node.type), 

319 node.name.id, 

320 self._visit(node.body)) 

321 return ast.copy_location(new_node, node) 

322 else: 

323 return self.generic_visit(node) 

324 

325 if sys.version_info.minor < 5: 

326 

327 def visit_Call(self, node): 

328 if node.args and isinstance(node.args[-1], gast.Starred): 

329 args = node.args[:-1] 

330 starargs = node.args[-1].value 

331 else: 

332 args = node.args 

333 starargs = None 

334 

335 if node.keywords and node.keywords[-1].arg is None: 

336 keywords = node.keywords[:-1] 

337 kwargs = node.keywords[-1].value 

338 else: 

339 keywords = node.keywords 

340 kwargs = None 

341 

342 new_node = ast.Call( 

343 self._visit(node.func), 

344 self._visit(args), 

345 self._visit(keywords), 

346 self._visit(starargs), 

347 self._visit(kwargs), 

348 ) 

349 return ast.copy_location(new_node, node) 

350 

351 def visit_ClassDef(self, node): 

352 self.generic_visit(node) 

353 new_node = ast.ClassDef( 

354 name=self._visit(node.name), 

355 bases=self._visit(node.bases), 

356 keywords=self._visit(node.keywords), 

357 body=self._visit(node.body), 

358 decorator_list=self._visit(node.decorator_list), 

359 starargs=None, 

360 kwargs=None, 

361 ) 

362 return ast.copy_location(new_node, node) 

363 

364 elif sys.version_info.minor < 8: 

365 

366 def visit_FunctionDef(self, node): 

367 new_node = ast.FunctionDef( 

368 self._visit(node.name), 

369 self._visit(node.args), 

370 self._visit(node.body), 

371 self._visit(node.decorator_list), 

372 self._visit(node.returns), 

373 ) 

374 return ast.copy_location(new_node, node) 

375 

376 def visit_AsyncFunctionDef(self, node): 

377 new_node = ast.AsyncFunctionDef( 

378 self._visit(node.name), 

379 self._visit(node.args), 

380 self._visit(node.body), 

381 self._visit(node.decorator_list), 

382 self._visit(node.returns), 

383 ) 

384 return ast.copy_location(new_node, node) 

385 

386 def visit_For(self, node): 

387 new_node = ast.For( 

388 self._visit(node.target), 

389 self._visit(node.iter), 

390 self._visit(node.body), 

391 self._visit(node.orelse), 

392 ) 

393 return ast.copy_location(new_node, node) 

394 

395 def visit_AsyncFor(self, node): 

396 new_node = ast.AsyncFor( 

397 self._visit(node.target), 

398 self._visit(node.iter), 

399 self._visit(node.body), 

400 self._visit(node.orelse), 

401 None, # type_comment 

402 ) 

403 return ast.copy_location(new_node, node) 

404 

405 def visit_With(self, node): 

406 new_node = ast.With( 

407 self._visit(node.items), 

408 self._visit(node.body), 

409 ) 

410 return ast.copy_location(new_node, node) 

411 

412 def visit_AsyncWith(self, node): 

413 new_node = ast.AsyncWith( 

414 self._visit(node.items), 

415 self._visit(node.body), 

416 ) 

417 return ast.copy_location(new_node, node) 

418 

419 def visit_Call(self, node): 

420 new_node = ast.Call( 

421 self._visit(node.func), 

422 self._visit(node.args), 

423 self._visit(node.keywords), 

424 ) 

425 return ast.copy_location(new_node, node) 

426 

427 def visit_arguments(self, node): 

428 extra_args = [self._make_arg(node.vararg), 

429 [self._make_arg(n) for n in node.kwonlyargs], 

430 self._visit(node.kw_defaults), 

431 self._make_arg(node.kwarg), 

432 self._visit(node.defaults), ] 

433 if sys.version_info.minor >= 8: 

434 new_node = ast.arguments( 

435 [self._make_arg(arg) for arg in node.posonlyargs], 

436 [self._make_arg(n) for n in node.args], 

437 *extra_args 

438 ) 

439 else: 

440 new_node = ast.arguments( 

441 [self._make_arg(n) for n in node.args], 

442 *extra_args 

443 ) 

444 return new_node 

445 

446 

447def ast_to_gast(node): 

448 return Ast3ToGAst().visit(node) 

449 

450 

451def gast_to_ast(node): 

452 return GAstToAst3().visit(node)