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

1from gast.astn import AstToGAst, GAstToAst 

2import gast 

3import ast 

4import sys 

5 

6 

7class Ast3ToGAst(AstToGAst): 

8 if sys.version_info.minor == 12: 

9 

10 def visit_TypeVar(self, node): 

11 new_node = gast.TypeVar( 

12 self._visit(node.name), 

13 self._visit(node.bound), 

14 None 

15 ) 

16 return gast.copy_location(new_node, node) 

17 

18 def visit_TypeVarTuple(self, node): 

19 new_node = gast.TypeVarTuple( 

20 self._visit(node.name), 

21 None 

22 ) 

23 return gast.copy_location(new_node, node) 

24 

25 def visit_ParamSpec(self, node): 

26 new_node = gast.ParamSpec( 

27 self._visit(node.name), 

28 None 

29 ) 

30 return gast.copy_location(new_node, node) 

31 

32 if sys.version_info.minor < 10: 

33 

34 def visit_alias(self, node): 

35 new_node = gast.alias( 

36 self._visit(node.name), 

37 self._visit(node.asname), 

38 ) 

39 new_node.lineno = new_node.col_offset = None 

40 new_node.end_lineno = new_node.end_col_offset = None 

41 return new_node 

42 

43 if sys.version_info.minor < 9: 

44 

45 def visit_ExtSlice(self, node): 

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

47 return gast.copy_location(new_node, node) 

48 

49 def visit_Index(self, node): 

50 return self._visit(node.value) 

51 

52 def visit_Assign(self, node): 

53 new_node = gast.Assign( 

54 self._visit(node.targets), 

55 self._visit(node.value), 

56 None, # type_comment 

57 ) 

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 if sys.version_info.minor < 8: 

64 def visit_Module(self, node): 

65 new_node = gast.Module( 

66 self._visit(node.body), 

67 [] # type_ignores 

68 ) 

69 return new_node 

70 

71 def visit_Num(self, node): 

72 new_node = gast.Constant( 

73 node.n, 

74 None, 

75 ) 

76 return gast.copy_location(new_node, node) 

77 

78 def visit_Ellipsis(self, node): 

79 new_node = gast.Constant( 

80 Ellipsis, 

81 None, 

82 ) 

83 gast.copy_location(new_node, node) 

84 new_node.end_lineno = new_node.end_col_offset = None 

85 return new_node 

86 

87 def visit_Str(self, node): 

88 new_node = gast.Constant( 

89 node.s, 

90 None, 

91 ) 

92 return gast.copy_location(new_node, node) 

93 

94 def visit_Bytes(self, node): 

95 new_node = gast.Constant( 

96 node.s, 

97 None, 

98 ) 

99 return gast.copy_location(new_node, node) 

100 

101 def visit_FunctionDef(self, node): 

102 new_node = gast.FunctionDef( 

103 self._visit(node.name), 

104 self._visit(node.args), 

105 self._visit(node.body), 

106 self._visit(node.decorator_list), 

107 self._visit(node.returns), 

108 None, # type_comment 

109 [], # type_params 

110 ) 

111 return gast.copy_location(new_node, node) 

112 

113 def visit_AsyncFunctionDef(self, node): 

114 new_node = gast.AsyncFunctionDef( 

115 self._visit(node.name), 

116 self._visit(node.args), 

117 self._visit(node.body), 

118 self._visit(node.decorator_list), 

119 self._visit(node.returns), 

120 None, # type_comment 

121 [], # type_params 

122 ) 

123 return gast.copy_location(new_node, node) 

124 

125 def visit_For(self, node): 

126 new_node = gast.For( 

127 self._visit(node.target), 

128 self._visit(node.iter), 

129 self._visit(node.body), 

130 self._visit(node.orelse), 

131 None, # type_comment 

132 ) 

133 return gast.copy_location(new_node, node) 

134 

135 def visit_AsyncFor(self, node): 

136 new_node = gast.AsyncFor( 

137 self._visit(node.target), 

138 self._visit(node.iter), 

139 self._visit(node.body), 

140 self._visit(node.orelse), 

141 None, # type_comment 

142 ) 

143 return gast.copy_location(new_node, node) 

144 

145 def visit_With(self, node): 

146 new_node = gast.With( 

147 self._visit(node.items), 

148 self._visit(node.body), 

149 None, # type_comment 

150 ) 

151 return gast.copy_location(new_node, node) 

152 

153 def visit_AsyncWith(self, node): 

154 new_node = gast.AsyncWith( 

155 self._visit(node.items), 

156 self._visit(node.body), 

157 None, # type_comment 

158 ) 

159 return gast.copy_location(new_node, node) 

160 

161 def visit_Call(self, node): 

162 if sys.version_info.minor < 5: 

163 if node.starargs: 

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

165 gast.Load()) 

166 gast.copy_location(star, node) 

167 starred = [star] 

168 else: 

169 starred = [] 

170 

171 if node.kwargs: 

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

173 gast.copy_location(kw, node.kwargs) 

174 kwargs = [kw] 

175 else: 

176 kwargs = [] 

177 else: 

178 starred = kwargs = [] 

179 

180 new_node = gast.Call( 

181 self._visit(node.func), 

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

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

184 ) 

185 return gast.copy_location(new_node, node) 

186 

187 def visit_NameConstant(self, node): 

188 if node.value is None: 

189 new_node = gast.Constant(None, None) 

190 elif node.value is True: 

191 new_node = gast.Constant(True, None) 

192 elif node.value is False: 

193 new_node = gast.Constant(False, None) 

194 return gast.copy_location(new_node, node) 

195 

196 def visit_arguments(self, node): 

197 new_node = gast.arguments( 

198 self._visit(node.args), 

199 [], # posonlyargs 

200 self._visit(node.vararg), 

201 self._visit(node.kwonlyargs), 

202 self._visit(node.kw_defaults), 

203 self._visit(node.kwarg), 

204 self._visit(node.defaults), 

205 ) 

206 return gast.copy_location(new_node, node) 

207 

208 def visit_Name(self, node): 

209 new_node = gast.Name( 

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

211 self._visit(node.ctx), 

212 None, 

213 None, 

214 ) 

215 return ast.copy_location(new_node, node) 

216 

217 def visit_arg(self, node): 

218 if sys.version_info.minor < 8: 

219 extra_arg = None 

220 else: 

221 extra_arg = self._visit(node.type_comment) 

222 

223 new_node = gast.Name( 

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

225 gast.Param(), 

226 self._visit(node.annotation), 

227 extra_arg # type_comment 

228 ) 

229 return ast.copy_location(new_node, node) 

230 

231 def visit_ExceptHandler(self, node): 

232 if node.name: 

233 new_node = gast.ExceptHandler( 

234 self._visit(node.type), 

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

236 self._visit(node.body)) 

237 return ast.copy_location(new_node, node) 

238 else: 

239 return self.generic_visit(node) 

240 

241 if sys.version_info.minor < 6: 

242 

243 def visit_comprehension(self, node): 

244 new_node = gast.comprehension( 

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

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

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

248 is_async=0, 

249 ) 

250 return ast.copy_location(new_node, node) 

251 

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

253 def visit_FunctionDef(self, node): 

254 new_node = gast.FunctionDef( 

255 self._visit(node.name), 

256 self._visit(node.args), 

257 self._visit(node.body), 

258 self._visit(node.decorator_list), 

259 self._visit(node.returns), 

260 self._visit(node.type_comment), 

261 [], # type_params 

262 ) 

263 return gast.copy_location(new_node, node) 

264 

265 def visit_AsyncFunctionDef(self, node): 

266 new_node = gast.AsyncFunctionDef( 

267 self._visit(node.name), 

268 self._visit(node.args), 

269 self._visit(node.body), 

270 self._visit(node.decorator_list), 

271 self._visit(node.returns), 

272 self._visit(node.type_comment), 

273 [], # type_params 

274 ) 

275 return gast.copy_location(new_node, node) 

276 

277 if sys.version_info.minor < 12: 

278 

279 def visit_ClassDef(self, node): 

280 new_node = gast.ClassDef( 

281 self._visit(node.name), 

282 self._visit(node.bases), 

283 self._visit(node.keywords), 

284 self._visit(node.body), 

285 self._visit(node.decorator_list), 

286 [], # type_params 

287 ) 

288 return gast.copy_location(new_node, node) 

289 

290 

291class GAstToAst3(GAstToAst): 

292 if sys.version_info.minor == 12: 

293 def visit_TypeVar(self, node): 

294 new_node = ast.TypeVar( 

295 self._visit(node.name), 

296 self._visit(node.bound) 

297 ) 

298 return ast.copy_location(new_node, node) 

299 

300 def visit_TypeVarTuple(self, node): 

301 new_node = ast.TypeVarTuple( 

302 self._visit(node.name), 

303 ) 

304 return ast.copy_location(new_node, node) 

305 

306 def visit_ParamSpec(self, node): 

307 new_node = ast.ParamSpec( 

308 self._visit(node.name), 

309 ) 

310 return ast.copy_location(new_node, node) 

311 

312 if sys.version_info.minor < 10: 

313 def visit_alias(self, node): 

314 new_node = ast.alias( 

315 self._visit(node.name), 

316 self._visit(node.asname) 

317 ) 

318 return new_node 

319 

320 if sys.version_info.minor < 9: 

321 def visit_Subscript(self, node): 

322 def adjust_slice(s): 

323 if isinstance(s, ast.Slice): 

324 return s 

325 else: 

326 return ast.Index(s) 

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

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

329 new_slice = ast.ExtSlice( 

330 [adjust_slice(x) for x in 

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

332 else: 

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

334 ast.copy_location(value, node.slice) 

335 new_slice = ast.Index(value) 

336 else: 

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

338 ast.copy_location(new_slice, node.slice) 

339 

340 new_node = ast.Subscript( 

341 self._visit(node.value), 

342 new_slice, 

343 self._visit(node.ctx), 

344 ) 

345 return ast.copy_location(new_node, node) 

346 

347 def visit_Assign(self, node): 

348 new_node = ast.Assign( 

349 self._visit(node.targets), 

350 self._visit(node.value), 

351 ) 

352 

353 return ast.copy_location(new_node, node) 

354 

355 if sys.version_info.minor < 8: 

356 

357 def visit_Module(self, node): 

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

359 return new_node 

360 

361 def visit_Constant(self, node): 

362 if node.value is None: 

363 new_node = ast.NameConstant(node.value) 

364 elif node.value is Ellipsis: 

365 new_node = ast.Ellipsis() 

366 elif isinstance(node.value, bool): 

367 new_node = ast.NameConstant(node.value) 

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

369 new_node = ast.Num(node.value) 

370 elif isinstance(node.value, str): 

371 new_node = ast.Str(node.value) 

372 else: 

373 new_node = ast.Bytes(node.value) 

374 return ast.copy_location(new_node, node) 

375 

376 def _make_arg(self, node): 

377 if node is None: 

378 return None 

379 

380 if sys.version_info.minor < 8: 

381 extra_args = tuple() 

382 else: 

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

384 

385 new_node = ast.arg( 

386 self._visit(node.id), 

387 self._visit(node.annotation), 

388 *extra_args 

389 ) 

390 return ast.copy_location(new_node, node) 

391 

392 def visit_Name(self, node): 

393 new_node = ast.Name( 

394 self._visit(node.id), 

395 self._visit(node.ctx), 

396 ) 

397 return ast.copy_location(new_node, node) 

398 

399 def visit_ExceptHandler(self, node): 

400 if node.name: 

401 new_node = ast.ExceptHandler( 

402 self._visit(node.type), 

403 node.name.id, 

404 self._visit(node.body)) 

405 return ast.copy_location(new_node, node) 

406 else: 

407 return self.generic_visit(node) 

408 

409 if sys.version_info.minor < 5: 

410 

411 def visit_Call(self, node): 

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

413 args = node.args[:-1] 

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

415 else: 

416 args = node.args 

417 starargs = None 

418 

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

420 keywords = node.keywords[:-1] 

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

422 else: 

423 keywords = node.keywords 

424 kwargs = None 

425 

426 new_node = ast.Call( 

427 self._visit(node.func), 

428 self._visit(args), 

429 self._visit(keywords), 

430 self._visit(starargs), 

431 self._visit(kwargs), 

432 ) 

433 return ast.copy_location(new_node, node) 

434 

435 def visit_ClassDef(self, node): 

436 self.generic_visit(node) 

437 new_node = ast.ClassDef( 

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

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

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

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

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

443 starargs=None, 

444 kwargs=None, 

445 ) 

446 return ast.copy_location(new_node, node) 

447 

448 elif sys.version_info.minor < 8: 

449 

450 def visit_FunctionDef(self, node): 

451 new_node = ast.FunctionDef( 

452 self._visit(node.name), 

453 self._visit(node.args), 

454 self._visit(node.body), 

455 self._visit(node.decorator_list), 

456 self._visit(node.returns), 

457 ) 

458 return ast.copy_location(new_node, node) 

459 

460 def visit_AsyncFunctionDef(self, node): 

461 new_node = ast.AsyncFunctionDef( 

462 self._visit(node.name), 

463 self._visit(node.args), 

464 self._visit(node.body), 

465 self._visit(node.decorator_list), 

466 self._visit(node.returns), 

467 ) 

468 return ast.copy_location(new_node, node) 

469 

470 def visit_For(self, node): 

471 new_node = ast.For( 

472 self._visit(node.target), 

473 self._visit(node.iter), 

474 self._visit(node.body), 

475 self._visit(node.orelse), 

476 ) 

477 return ast.copy_location(new_node, node) 

478 

479 def visit_AsyncFor(self, node): 

480 new_node = ast.AsyncFor( 

481 self._visit(node.target), 

482 self._visit(node.iter), 

483 self._visit(node.body), 

484 self._visit(node.orelse), 

485 None, # type_comment 

486 ) 

487 return ast.copy_location(new_node, node) 

488 

489 def visit_With(self, node): 

490 new_node = ast.With( 

491 self._visit(node.items), 

492 self._visit(node.body), 

493 ) 

494 return ast.copy_location(new_node, node) 

495 

496 def visit_AsyncWith(self, node): 

497 new_node = ast.AsyncWith( 

498 self._visit(node.items), 

499 self._visit(node.body), 

500 ) 

501 return ast.copy_location(new_node, node) 

502 

503 def visit_Call(self, node): 

504 new_node = ast.Call( 

505 self._visit(node.func), 

506 self._visit(node.args), 

507 self._visit(node.keywords), 

508 ) 

509 return ast.copy_location(new_node, node) 

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

511 def visit_ClassDef(self, node): 

512 new_node = ast.ClassDef( 

513 self._visit(node.name), 

514 self._visit(node.bases), 

515 self._visit(node.keywords), 

516 self._visit(node.body), 

517 self._visit(node.decorator_list), 

518 ) 

519 return ast.copy_location(new_node, node) 

520 

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

522 def visit_FunctionDef(self, node): 

523 new_node = ast.FunctionDef( 

524 self._visit(node.name), 

525 self._visit(node.args), 

526 self._visit(node.body), 

527 self._visit(node.decorator_list), 

528 self._visit(node.returns), 

529 self._visit(node.type_comment), 

530 ) 

531 return ast.copy_location(new_node, node) 

532 

533 def visit_AsyncFunctionDef(self, node): 

534 new_node = ast.AsyncFunctionDef( 

535 self._visit(node.name), 

536 self._visit(node.args), 

537 self._visit(node.body), 

538 self._visit(node.decorator_list), 

539 self._visit(node.returns), 

540 self._visit(node.type_comment), 

541 ) 

542 return ast.copy_location(new_node, node) 

543 

544 

545 

546 def visit_arguments(self, node): 

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

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

549 self._visit(node.kw_defaults), 

550 self._make_arg(node.kwarg), 

551 self._visit(node.defaults), ] 

552 if sys.version_info.minor >= 8: 

553 new_node = ast.arguments( 

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

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

556 *extra_args 

557 ) 

558 else: 

559 new_node = ast.arguments( 

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

561 *extra_args 

562 ) 

563 return new_node 

564 

565 

566def ast_to_gast(node): 

567 return Ast3ToGAst().visit(node) 

568 

569 

570def gast_to_ast(node): 

571 return GAstToAst3().visit(node)