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

1from gast.astn import AstToGAst, GAstToAst 

2import gast 

3import ast 

4import sys 

5 

6 

7class Ast3ToGAst(AstToGAst): 

8 if sys.version_info.minor < 9: 

9 

10 def visit_ExtSlice(self, node): 

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

12 gast.copy_location(new_node, node) 

13 return new_node 

14 

15 def visit_Index(self, node): 

16 return self._visit(node.value) 

17 

18 if sys.version_info.minor < 8: 

19 def visit_Module(self, node): 

20 new_node = gast.Module( 

21 self._visit(node.body), 

22 [] # type_ignores 

23 ) 

24 return new_node 

25 

26 def visit_Num(self, node): 

27 new_node = gast.Constant( 

28 node.n, 

29 None, 

30 ) 

31 gast.copy_location(new_node, node) 

32 return new_node 

33 

34 def visit_Ellipsis(self, node): 

35 new_node = gast.Constant( 

36 Ellipsis, 

37 None, 

38 ) 

39 gast.copy_location(new_node, node) 

40 new_node.end_lineno = new_node.end_col_offset = None 

41 return new_node 

42 

43 def visit_Str(self, node): 

44 new_node = gast.Constant( 

45 node.s, 

46 None, 

47 ) 

48 gast.copy_location(new_node, node) 

49 return new_node 

50 

51 def visit_Bytes(self, node): 

52 new_node = gast.Constant( 

53 node.s, 

54 None, 

55 ) 

56 gast.copy_location(new_node, node) 

57 return new_node 

58 

59 def visit_FunctionDef(self, node): 

60 new_node = gast.FunctionDef( 

61 self._visit(node.name), 

62 self._visit(node.args), 

63 self._visit(node.body), 

64 self._visit(node.decorator_list), 

65 self._visit(node.returns), 

66 None, # type_comment 

67 ) 

68 gast.copy_location(new_node, node) 

69 return new_node 

70 

71 def visit_AsyncFunctionDef(self, node): 

72 new_node = gast.AsyncFunctionDef( 

73 self._visit(node.name), 

74 self._visit(node.args), 

75 self._visit(node.body), 

76 self._visit(node.decorator_list), 

77 self._visit(node.returns), 

78 None, # type_comment 

79 ) 

80 gast.copy_location(new_node, node) 

81 return new_node 

82 

83 def visit_For(self, node): 

84 new_node = gast.For( 

85 self._visit(node.target), 

86 self._visit(node.iter), 

87 self._visit(node.body), 

88 self._visit(node.orelse), 

89 None, # type_comment 

90 ) 

91 gast.copy_location(new_node, node) 

92 return new_node 

93 

94 def visit_AsyncFor(self, node): 

95 new_node = gast.AsyncFor( 

96 self._visit(node.target), 

97 self._visit(node.iter), 

98 self._visit(node.body), 

99 self._visit(node.orelse), 

100 None, # type_comment 

101 ) 

102 gast.copy_location(new_node, node) 

103 return new_node 

104 

105 def visit_With(self, node): 

106 new_node = gast.With( 

107 self._visit(node.items), 

108 self._visit(node.body), 

109 None, # type_comment 

110 ) 

111 gast.copy_location(new_node, node) 

112 return new_node 

113 

114 def visit_AsyncWith(self, node): 

115 new_node = gast.AsyncWith( 

116 self._visit(node.items), 

117 self._visit(node.body), 

118 None, # type_comment 

119 ) 

120 gast.copy_location(new_node, node) 

121 return new_node 

122 

123 def visit_Call(self, node): 

124 if sys.version_info.minor < 5: 

125 if node.starargs: 

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

127 gast.Load()) 

128 gast.copy_location(star, node) 

129 starred = [star] 

130 else: 

131 starred = [] 

132 

133 if node.kwargs: 

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

135 gast.copy_location(kw, node.kwargs) 

136 kwargs = [kw] 

137 else: 

138 kwargs = [] 

139 else: 

140 starred = kwargs = [] 

141 

142 new_node = gast.Call( 

143 self._visit(node.func), 

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

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

146 ) 

147 gast.copy_location(new_node, node) 

148 return new_node 

149 

150 def visit_NameConstant(self, node): 

151 if node.value is None: 

152 new_node = gast.Constant(None, None) 

153 elif node.value is True: 

154 new_node = gast.Constant(True, None) 

155 elif node.value is False: 

156 new_node = gast.Constant(False, None) 

157 gast.copy_location(new_node, node) 

158 return new_node 

159 

160 def visit_arguments(self, node): 

161 new_node = gast.arguments( 

162 self._visit(node.args), 

163 [], # posonlyargs 

164 self._visit(node.vararg), 

165 self._visit(node.kwonlyargs), 

166 self._visit(node.kw_defaults), 

167 self._visit(node.kwarg), 

168 self._visit(node.defaults), 

169 ) 

170 gast.copy_location(new_node, node) 

171 return new_node 

172 

173 def visit_Name(self, node): 

174 new_node = gast.Name( 

175 self._visit(node.id), 

176 self._visit(node.ctx), 

177 None, 

178 None, 

179 ) 

180 ast.copy_location(new_node, node) 

181 return new_node 

182 

183 def visit_arg(self, node): 

184 if sys.version_info.minor < 8: 

185 extra_args = [None] 

186 else: 

187 extra_args = [self._visit(node.type_comment)] 

188 

189 new_node = gast.Name( 

190 self._visit(node.arg), 

191 gast.Param(), 

192 self._visit(node.annotation), 

193 *extra_args # type_comment 

194 ) 

195 ast.copy_location(new_node, node) 

196 return new_node 

197 

198 def visit_ExceptHandler(self, node): 

199 if node.name: 

200 new_node = gast.ExceptHandler( 

201 self._visit(node.type), 

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

203 self._visit(node.body)) 

204 ast.copy_location(new_node, node) 

205 return new_node 

206 else: 

207 return self.generic_visit(node) 

208 

209 if sys.version_info.minor < 6: 

210 

211 def visit_comprehension(self, node): 

212 new_node = gast.comprehension( 

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

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

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

216 is_async=0, 

217 ) 

218 return ast.copy_location(new_node, node) 

219 

220 

221class GAstToAst3(GAstToAst): 

222 if sys.version_info.minor < 9: 

223 def visit_Subscript(self, node): 

224 def adjust_slice(s): 

225 if isinstance(s, ast.Slice): 

226 return s 

227 else: 

228 return ast.Index(s) 

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

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

231 new_slice = ast.ExtSlice( 

232 [adjust_slice(x) for x in 

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

234 else: 

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

236 ast.copy_location(value, node.slice) 

237 new_slice = ast.Index(value) 

238 else: 

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

240 ast.copy_location(new_slice, node.slice) 

241 

242 new_node = ast.Subscript( 

243 self._visit(node.value), 

244 new_slice, 

245 self._visit(node.ctx), 

246 ) 

247 ast.copy_location(new_node, node) 

248 return new_node 

249 

250 if sys.version_info.minor < 8: 

251 

252 def visit_Module(self, node): 

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

254 return new_node 

255 

256 def visit_Constant(self, node): 

257 if node.value is None: 

258 new_node = ast.NameConstant(node.value) 

259 elif node.value is Ellipsis: 

260 new_node = ast.Ellipsis() 

261 elif isinstance(node.value, bool): 

262 new_node = ast.NameConstant(node.value) 

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

264 new_node = ast.Num(node.value) 

265 elif isinstance(node.value, str): 

266 new_node = ast.Str(node.value) 

267 else: 

268 new_node = ast.Bytes(node.value) 

269 ast.copy_location(new_node, node) 

270 return new_node 

271 

272 def _make_arg(self, node): 

273 if node is None: 

274 return None 

275 

276 if sys.version_info.minor < 8: 

277 extra_args = tuple() 

278 else: 

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

280 

281 new_node = ast.arg( 

282 self._visit(node.id), 

283 self._visit(node.annotation), 

284 *extra_args 

285 ) 

286 return ast.copy_location(new_node, node) 

287 

288 def visit_Name(self, node): 

289 new_node = ast.Name( 

290 self._visit(node.id), 

291 self._visit(node.ctx), 

292 ) 

293 ast.copy_location(new_node, node) 

294 return new_node 

295 

296 def visit_ExceptHandler(self, node): 

297 if node.name: 

298 new_node = ast.ExceptHandler( 

299 self._visit(node.type), 

300 node.name.id, 

301 self._visit(node.body)) 

302 return ast.copy_location(new_node, node) 

303 else: 

304 return self.generic_visit(node) 

305 

306 if sys.version_info.minor < 5: 

307 

308 def visit_Call(self, node): 

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

310 args = node.args[:-1] 

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

312 else: 

313 args = node.args 

314 starargs = None 

315 

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

317 keywords = node.keywords[:-1] 

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

319 else: 

320 keywords = node.keywords 

321 kwargs = None 

322 

323 new_node = ast.Call( 

324 self._visit(node.func), 

325 self._visit(args), 

326 self._visit(keywords), 

327 self._visit(starargs), 

328 self._visit(kwargs), 

329 ) 

330 ast.copy_location(new_node, node) 

331 return new_node 

332 

333 def visit_ClassDef(self, node): 

334 self.generic_visit(node) 

335 new_node = ast.ClassDef( 

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

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

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

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

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

341 starargs=None, 

342 kwargs=None, 

343 ) 

344 return ast.copy_location(new_node, node) 

345 

346 elif sys.version_info.minor < 8: 

347 

348 def visit_FunctionDef(self, node): 

349 new_node = ast.FunctionDef( 

350 self._visit(node.name), 

351 self._visit(node.args), 

352 self._visit(node.body), 

353 self._visit(node.decorator_list), 

354 self._visit(node.returns), 

355 ) 

356 ast.copy_location(new_node, node) 

357 return new_node 

358 

359 def visit_AsyncFunctionDef(self, node): 

360 new_node = ast.AsyncFunctionDef( 

361 self._visit(node.name), 

362 self._visit(node.args), 

363 self._visit(node.body), 

364 self._visit(node.decorator_list), 

365 self._visit(node.returns), 

366 ) 

367 ast.copy_location(new_node, node) 

368 return new_node 

369 

370 def visit_For(self, node): 

371 new_node = ast.For( 

372 self._visit(node.target), 

373 self._visit(node.iter), 

374 self._visit(node.body), 

375 self._visit(node.orelse), 

376 ) 

377 ast.copy_location(new_node, node) 

378 return new_node 

379 

380 def visit_AsyncFor(self, node): 

381 new_node = ast.AsyncFor( 

382 self._visit(node.target), 

383 self._visit(node.iter), 

384 self._visit(node.body), 

385 self._visit(node.orelse), 

386 None, # type_comment 

387 ) 

388 ast.copy_location(new_node, node) 

389 return new_node 

390 

391 def visit_With(self, node): 

392 new_node = ast.With( 

393 self._visit(node.items), 

394 self._visit(node.body), 

395 ) 

396 ast.copy_location(new_node, node) 

397 return new_node 

398 

399 def visit_AsyncWith(self, node): 

400 new_node = ast.AsyncWith( 

401 self._visit(node.items), 

402 self._visit(node.body), 

403 ) 

404 ast.copy_location(new_node, node) 

405 return new_node 

406 

407 def visit_Call(self, node): 

408 new_node = ast.Call( 

409 self._visit(node.func), 

410 self._visit(node.args), 

411 self._visit(node.keywords), 

412 ) 

413 ast.copy_location(new_node, node) 

414 return new_node 

415 

416 def visit_arguments(self, node): 

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

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

419 self._visit(node.kw_defaults), 

420 self._make_arg(node.kwarg), 

421 self._visit(node.defaults), ] 

422 if sys.version_info.minor >= 8: 

423 new_node = ast.arguments( 

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

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

426 *extra_args 

427 ) 

428 else: 

429 new_node = ast.arguments( 

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

431 *extra_args 

432 ) 

433 return new_node 

434 

435 

436def ast_to_gast(node): 

437 return Ast3ToGAst().visit(node) 

438 

439 

440def gast_to_ast(node): 

441 return GAstToAst3().visit(node)