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

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 [], # type_params 

86 ) 

87 return gast.copy_location(new_node, node) 

88 

89 def visit_AsyncFunctionDef(self, node): 

90 new_node = gast.AsyncFunctionDef( 

91 self._visit(node.name), 

92 self._visit(node.args), 

93 self._visit(node.body), 

94 self._visit(node.decorator_list), 

95 self._visit(node.returns), 

96 None, # type_comment 

97 [], # type_params 

98 ) 

99 return gast.copy_location(new_node, node) 

100 

101 def visit_For(self, node): 

102 new_node = gast.For( 

103 self._visit(node.target), 

104 self._visit(node.iter), 

105 self._visit(node.body), 

106 self._visit(node.orelse), 

107 None, # type_comment 

108 ) 

109 return gast.copy_location(new_node, node) 

110 

111 def visit_AsyncFor(self, node): 

112 new_node = gast.AsyncFor( 

113 self._visit(node.target), 

114 self._visit(node.iter), 

115 self._visit(node.body), 

116 self._visit(node.orelse), 

117 None, # type_comment 

118 ) 

119 return gast.copy_location(new_node, node) 

120 

121 def visit_With(self, node): 

122 new_node = gast.With( 

123 self._visit(node.items), 

124 self._visit(node.body), 

125 None, # type_comment 

126 ) 

127 return gast.copy_location(new_node, node) 

128 

129 def visit_AsyncWith(self, node): 

130 new_node = gast.AsyncWith( 

131 self._visit(node.items), 

132 self._visit(node.body), 

133 None, # type_comment 

134 ) 

135 return gast.copy_location(new_node, node) 

136 

137 def visit_Call(self, node): 

138 if sys.version_info.minor < 5: 

139 if node.starargs: 

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

141 gast.Load()) 

142 gast.copy_location(star, node) 

143 starred = [star] 

144 else: 

145 starred = [] 

146 

147 if node.kwargs: 

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

149 gast.copy_location(kw, node.kwargs) 

150 kwargs = [kw] 

151 else: 

152 kwargs = [] 

153 else: 

154 starred = kwargs = [] 

155 

156 new_node = gast.Call( 

157 self._visit(node.func), 

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

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

160 ) 

161 return gast.copy_location(new_node, node) 

162 

163 def visit_NameConstant(self, node): 

164 if node.value is None: 

165 new_node = gast.Constant(None, None) 

166 elif node.value is True: 

167 new_node = gast.Constant(True, None) 

168 elif node.value is False: 

169 new_node = gast.Constant(False, None) 

170 return gast.copy_location(new_node, node) 

171 

172 def visit_arguments(self, node): 

173 new_node = gast.arguments( 

174 self._visit(node.args), 

175 [], # posonlyargs 

176 self._visit(node.vararg), 

177 self._visit(node.kwonlyargs), 

178 self._visit(node.kw_defaults), 

179 self._visit(node.kwarg), 

180 self._visit(node.defaults), 

181 ) 

182 return gast.copy_location(new_node, node) 

183 

184 def visit_Name(self, node): 

185 new_node = gast.Name( 

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

187 self._visit(node.ctx), 

188 None, 

189 None, 

190 ) 

191 return ast.copy_location(new_node, node) 

192 

193 def visit_arg(self, node): 

194 if sys.version_info.minor < 8: 

195 extra_arg = None 

196 else: 

197 extra_arg = self._visit(node.type_comment) 

198 

199 new_node = gast.Name( 

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

201 gast.Param(), 

202 self._visit(node.annotation), 

203 extra_arg # type_comment 

204 ) 

205 return ast.copy_location(new_node, node) 

206 

207 def visit_ExceptHandler(self, node): 

208 if node.name: 

209 new_node = gast.ExceptHandler( 

210 self._visit(node.type), 

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

212 self._visit(node.body)) 

213 return ast.copy_location(new_node, node) 

214 else: 

215 return self.generic_visit(node) 

216 

217 if sys.version_info.minor < 6: 

218 

219 def visit_comprehension(self, node): 

220 new_node = gast.comprehension( 

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

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

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

224 is_async=0, 

225 ) 

226 return ast.copy_location(new_node, node) 

227 

228 if 8 <= sys.version_info.minor < 12: 

229 def visit_FunctionDef(self, node): 

230 new_node = gast.FunctionDef( 

231 self._visit(node.name), 

232 self._visit(node.args), 

233 self._visit(node.body), 

234 self._visit(node.decorator_list), 

235 self._visit(node.returns), 

236 self._visit(node.type_comment), 

237 [], # type_params 

238 ) 

239 return gast.copy_location(new_node, node) 

240 

241 def visit_AsyncFunctionDef(self, node): 

242 new_node = gast.AsyncFunctionDef( 

243 self._visit(node.name), 

244 self._visit(node.args), 

245 self._visit(node.body), 

246 self._visit(node.decorator_list), 

247 self._visit(node.returns), 

248 self._visit(node.type_comment), 

249 [], # type_params 

250 ) 

251 return gast.copy_location(new_node, node) 

252 

253 if sys.version_info.minor < 12: 

254 

255 def visit_ClassDef(self, node): 

256 new_node = gast.ClassDef( 

257 self._visit(node.name), 

258 self._visit(node.bases), 

259 self._visit(node.keywords), 

260 self._visit(node.body), 

261 self._visit(node.decorator_list), 

262 [], # type_params 

263 ) 

264 return gast.copy_location(new_node, node) 

265 

266 

267class GAstToAst3(GAstToAst): 

268 if sys.version_info.minor < 10: 

269 def visit_alias(self, node): 

270 new_node = ast.alias( 

271 self._visit(node.name), 

272 self._visit(node.asname) 

273 ) 

274 return new_node 

275 

276 if sys.version_info.minor < 9: 

277 def visit_Subscript(self, node): 

278 def adjust_slice(s): 

279 if isinstance(s, ast.Slice): 

280 return s 

281 else: 

282 return ast.Index(s) 

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

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

285 new_slice = ast.ExtSlice( 

286 [adjust_slice(x) for x in 

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

288 else: 

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

290 ast.copy_location(value, node.slice) 

291 new_slice = ast.Index(value) 

292 else: 

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

294 ast.copy_location(new_slice, node.slice) 

295 

296 new_node = ast.Subscript( 

297 self._visit(node.value), 

298 new_slice, 

299 self._visit(node.ctx), 

300 ) 

301 return ast.copy_location(new_node, node) 

302 

303 def visit_Assign(self, node): 

304 new_node = ast.Assign( 

305 self._visit(node.targets), 

306 self._visit(node.value), 

307 ) 

308 

309 return ast.copy_location(new_node, node) 

310 

311 if sys.version_info.minor < 8: 

312 

313 def visit_Module(self, node): 

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

315 return new_node 

316 

317 def visit_Constant(self, node): 

318 if node.value is None: 

319 new_node = ast.NameConstant(node.value) 

320 elif node.value is Ellipsis: 

321 new_node = ast.Ellipsis() 

322 elif isinstance(node.value, bool): 

323 new_node = ast.NameConstant(node.value) 

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

325 new_node = ast.Num(node.value) 

326 elif isinstance(node.value, str): 

327 new_node = ast.Str(node.value) 

328 else: 

329 new_node = ast.Bytes(node.value) 

330 return ast.copy_location(new_node, node) 

331 

332 def _make_arg(self, node): 

333 if node is None: 

334 return None 

335 

336 if sys.version_info.minor < 8: 

337 extra_args = tuple() 

338 else: 

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

340 

341 new_node = ast.arg( 

342 self._visit(node.id), 

343 self._visit(node.annotation), 

344 *extra_args 

345 ) 

346 return ast.copy_location(new_node, node) 

347 

348 def visit_Name(self, node): 

349 new_node = ast.Name( 

350 self._visit(node.id), 

351 self._visit(node.ctx), 

352 ) 

353 return ast.copy_location(new_node, node) 

354 

355 def visit_ExceptHandler(self, node): 

356 if node.name: 

357 new_node = ast.ExceptHandler( 

358 self._visit(node.type), 

359 node.name.id, 

360 self._visit(node.body)) 

361 return ast.copy_location(new_node, node) 

362 else: 

363 return self.generic_visit(node) 

364 

365 if sys.version_info.minor < 5: 

366 

367 def visit_Call(self, node): 

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

369 args = node.args[:-1] 

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

371 else: 

372 args = node.args 

373 starargs = None 

374 

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

376 keywords = node.keywords[:-1] 

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

378 else: 

379 keywords = node.keywords 

380 kwargs = None 

381 

382 new_node = ast.Call( 

383 self._visit(node.func), 

384 self._visit(args), 

385 self._visit(keywords), 

386 self._visit(starargs), 

387 self._visit(kwargs), 

388 ) 

389 return ast.copy_location(new_node, node) 

390 

391 def visit_ClassDef(self, node): 

392 self.generic_visit(node) 

393 new_node = ast.ClassDef( 

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

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

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

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

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

399 starargs=None, 

400 kwargs=None, 

401 ) 

402 return ast.copy_location(new_node, node) 

403 

404 elif sys.version_info.minor < 8: 

405 

406 def visit_FunctionDef(self, node): 

407 new_node = ast.FunctionDef( 

408 self._visit(node.name), 

409 self._visit(node.args), 

410 self._visit(node.body), 

411 self._visit(node.decorator_list), 

412 self._visit(node.returns), 

413 ) 

414 return ast.copy_location(new_node, node) 

415 

416 def visit_AsyncFunctionDef(self, node): 

417 new_node = ast.AsyncFunctionDef( 

418 self._visit(node.name), 

419 self._visit(node.args), 

420 self._visit(node.body), 

421 self._visit(node.decorator_list), 

422 self._visit(node.returns), 

423 ) 

424 return ast.copy_location(new_node, node) 

425 

426 def visit_For(self, node): 

427 new_node = ast.For( 

428 self._visit(node.target), 

429 self._visit(node.iter), 

430 self._visit(node.body), 

431 self._visit(node.orelse), 

432 ) 

433 return ast.copy_location(new_node, node) 

434 

435 def visit_AsyncFor(self, node): 

436 new_node = ast.AsyncFor( 

437 self._visit(node.target), 

438 self._visit(node.iter), 

439 self._visit(node.body), 

440 self._visit(node.orelse), 

441 None, # type_comment 

442 ) 

443 return ast.copy_location(new_node, node) 

444 

445 def visit_With(self, node): 

446 new_node = ast.With( 

447 self._visit(node.items), 

448 self._visit(node.body), 

449 ) 

450 return ast.copy_location(new_node, node) 

451 

452 def visit_AsyncWith(self, node): 

453 new_node = ast.AsyncWith( 

454 self._visit(node.items), 

455 self._visit(node.body), 

456 ) 

457 return ast.copy_location(new_node, node) 

458 

459 def visit_Call(self, node): 

460 new_node = ast.Call( 

461 self._visit(node.func), 

462 self._visit(node.args), 

463 self._visit(node.keywords), 

464 ) 

465 return ast.copy_location(new_node, node) 

466 if 5 <= sys.version_info.minor < 12: 

467 def visit_ClassDef(self, node): 

468 new_node = ast.ClassDef( 

469 self._visit(node.name), 

470 self._visit(node.bases), 

471 self._visit(node.keywords), 

472 self._visit(node.body), 

473 self._visit(node.decorator_list), 

474 ) 

475 return ast.copy_location(new_node, node) 

476 

477 if 8 <= sys.version_info.minor < 12: 

478 def visit_FunctionDef(self, node): 

479 new_node = ast.FunctionDef( 

480 self._visit(node.name), 

481 self._visit(node.args), 

482 self._visit(node.body), 

483 self._visit(node.decorator_list), 

484 self._visit(node.returns), 

485 self._visit(node.type_comment), 

486 ) 

487 return ast.copy_location(new_node, node) 

488 

489 def visit_AsyncFunctionDef(self, node): 

490 new_node = ast.AsyncFunctionDef( 

491 self._visit(node.name), 

492 self._visit(node.args), 

493 self._visit(node.body), 

494 self._visit(node.decorator_list), 

495 self._visit(node.returns), 

496 self._visit(node.type_comment), 

497 ) 

498 return ast.copy_location(new_node, node) 

499 

500 

501 

502 def visit_arguments(self, node): 

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

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

505 self._visit(node.kw_defaults), 

506 self._make_arg(node.kwarg), 

507 self._visit(node.defaults), ] 

508 if sys.version_info.minor >= 8: 

509 new_node = ast.arguments( 

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

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

512 *extra_args 

513 ) 

514 else: 

515 new_node = ast.arguments( 

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

517 *extra_args 

518 ) 

519 return new_node 

520 

521 

522def ast_to_gast(node): 

523 return Ast3ToGAst().visit(node) 

524 

525 

526def gast_to_ast(node): 

527 return GAstToAst3().visit(node)