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 == 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 self._visit(getattr(node, 'type_comment', None)), 

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 if sys.version_info >= (3, 8): 

349 new_node = ast.Assign( 

350 self._visit(node.targets), 

351 self._visit(node.value), 

352 type_comment=self._visit(node.type_comment), 

353 ) 

354 else: 

355 new_node = ast.Assign( 

356 self._visit(node.targets), 

357 self._visit(node.value), 

358 ) 

359 

360 return ast.copy_location(new_node, node) 

361 

362 if sys.version_info.minor < 8: 

363 

364 def visit_Module(self, node): 

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

366 return new_node 

367 

368 def visit_Constant(self, node): 

369 if node.value is None: 

370 new_node = ast.NameConstant(node.value) 

371 elif node.value is Ellipsis: 

372 new_node = ast.Ellipsis() 

373 elif isinstance(node.value, bool): 

374 new_node = ast.NameConstant(node.value) 

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

376 new_node = ast.Num(node.value) 

377 elif isinstance(node.value, str): 

378 new_node = ast.Str(node.value) 

379 else: 

380 new_node = ast.Bytes(node.value) 

381 return ast.copy_location(new_node, node) 

382 

383 def _make_arg(self, node): 

384 if node is None: 

385 return None 

386 

387 if sys.version_info.minor < 8: 

388 extra_args = tuple() 

389 else: 

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

391 

392 new_node = ast.arg( 

393 self._visit(node.id), 

394 self._visit(node.annotation), 

395 *extra_args 

396 ) 

397 return ast.copy_location(new_node, node) 

398 

399 def visit_Name(self, node): 

400 new_node = ast.Name( 

401 self._visit(node.id), 

402 self._visit(node.ctx), 

403 ) 

404 return ast.copy_location(new_node, node) 

405 

406 def visit_ExceptHandler(self, node): 

407 if node.name: 

408 new_node = ast.ExceptHandler( 

409 self._visit(node.type), 

410 node.name.id, 

411 self._visit(node.body)) 

412 return ast.copy_location(new_node, node) 

413 else: 

414 return self.generic_visit(node) 

415 

416 if sys.version_info.minor < 5: 

417 

418 def visit_Call(self, node): 

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

420 args = node.args[:-1] 

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

422 else: 

423 args = node.args 

424 starargs = None 

425 

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

427 keywords = node.keywords[:-1] 

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

429 else: 

430 keywords = node.keywords 

431 kwargs = None 

432 

433 new_node = ast.Call( 

434 self._visit(node.func), 

435 self._visit(args), 

436 self._visit(keywords), 

437 self._visit(starargs), 

438 self._visit(kwargs), 

439 ) 

440 return ast.copy_location(new_node, node) 

441 

442 def visit_ClassDef(self, node): 

443 self.generic_visit(node) 

444 new_node = ast.ClassDef( 

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

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

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

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

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

450 starargs=None, 

451 kwargs=None, 

452 ) 

453 return ast.copy_location(new_node, node) 

454 

455 elif sys.version_info.minor < 8: 

456 

457 def visit_FunctionDef(self, node): 

458 new_node = ast.FunctionDef( 

459 self._visit(node.name), 

460 self._visit(node.args), 

461 self._visit(node.body), 

462 self._visit(node.decorator_list), 

463 self._visit(node.returns), 

464 ) 

465 return ast.copy_location(new_node, node) 

466 

467 def visit_AsyncFunctionDef(self, node): 

468 new_node = ast.AsyncFunctionDef( 

469 self._visit(node.name), 

470 self._visit(node.args), 

471 self._visit(node.body), 

472 self._visit(node.decorator_list), 

473 self._visit(node.returns), 

474 ) 

475 return ast.copy_location(new_node, node) 

476 

477 def visit_For(self, node): 

478 new_node = ast.For( 

479 self._visit(node.target), 

480 self._visit(node.iter), 

481 self._visit(node.body), 

482 self._visit(node.orelse), 

483 ) 

484 return ast.copy_location(new_node, node) 

485 

486 def visit_AsyncFor(self, node): 

487 new_node = ast.AsyncFor( 

488 self._visit(node.target), 

489 self._visit(node.iter), 

490 self._visit(node.body), 

491 self._visit(node.orelse), 

492 None, # type_comment 

493 ) 

494 return ast.copy_location(new_node, node) 

495 

496 def visit_With(self, node): 

497 new_node = ast.With( 

498 self._visit(node.items), 

499 self._visit(node.body), 

500 ) 

501 return ast.copy_location(new_node, node) 

502 

503 def visit_AsyncWith(self, node): 

504 new_node = ast.AsyncWith( 

505 self._visit(node.items), 

506 self._visit(node.body), 

507 ) 

508 return ast.copy_location(new_node, node) 

509 

510 def visit_Call(self, node): 

511 new_node = ast.Call( 

512 self._visit(node.func), 

513 self._visit(node.args), 

514 self._visit(node.keywords), 

515 ) 

516 return ast.copy_location(new_node, node) 

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

518 def visit_ClassDef(self, node): 

519 new_node = ast.ClassDef( 

520 self._visit(node.name), 

521 self._visit(node.bases), 

522 self._visit(node.keywords), 

523 self._visit(node.body), 

524 self._visit(node.decorator_list), 

525 ) 

526 return ast.copy_location(new_node, node) 

527 

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

529 def visit_FunctionDef(self, node): 

530 new_node = ast.FunctionDef( 

531 self._visit(node.name), 

532 self._visit(node.args), 

533 self._visit(node.body), 

534 self._visit(node.decorator_list), 

535 self._visit(node.returns), 

536 self._visit(node.type_comment), 

537 ) 

538 return ast.copy_location(new_node, node) 

539 

540 def visit_AsyncFunctionDef(self, node): 

541 new_node = ast.AsyncFunctionDef( 

542 self._visit(node.name), 

543 self._visit(node.args), 

544 self._visit(node.body), 

545 self._visit(node.decorator_list), 

546 self._visit(node.returns), 

547 self._visit(node.type_comment), 

548 ) 

549 return ast.copy_location(new_node, node) 

550 

551 

552 

553 def visit_arguments(self, node): 

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

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

556 self._visit(node.kw_defaults), 

557 self._make_arg(node.kwarg), 

558 self._visit(node.defaults), ] 

559 if sys.version_info.minor >= 8: 

560 new_node = ast.arguments( 

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

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

563 *extra_args 

564 ) 

565 else: 

566 new_node = ast.arguments( 

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

568 *extra_args 

569 ) 

570 return new_node 

571 

572 

573def ast_to_gast(node): 

574 return Ast3ToGAst().visit(node) 

575 

576 

577def gast_to_ast(node): 

578 return GAstToAst3().visit(node)